20240321, 字符串操作，STRING.H，字符串函数的实现

啥意思，这个循环是？每次给P分配一个字节，然后把那个位置写入0？但是0是整数吧？他需要四个字节？？？这和0地址有什么关系……啊啊啊啊啊

一，字符串操作

1.0 字符数组补

0标志字符串的结束，但它不是字符串的一部分
计算字符串长度的时候不包含这个0字符串以数组的形式存在，以数组或指针的形式访问更多的是以指针的形式
string.h里有很多处理字符串的函数

	//字符数组char word[] = { 'h','e','l','l','o', };//字符串char w[] = { 'h','e','l','l','0','\0' };//字符串就是以0或‘\0'结尾的字符数组，注意‘0’是0字符//0表示的是INT 要四个字节，\0一定是一个字节的东西

	char* str = "hello";//STR是指针，指向了数组{HELLO}char word[] = "hello";//字符数组，内容是HELLOchar line[10] = "hello";//十个字符的字符数组，放了5个字符，占6个空间，包括结尾的0//字面量表达之后，编译器自动生成的

一定要有结尾的0才是字符串
两串相邻的自动连成一串

	printf("的份额服务""feefwefwevwf\n");printf("的份额服务\feefwefwevwf\n");
//会把前面回退一起输出，\表示输出没有结束

C语言的字符串是以字符数组的形态存在的
不能用运算符对字符串做运算
通过数组的方式可以遍历字符串
唯一特殊的地方是字符串字面量可以用来初始化字符数组
以及标准库提供了一系列字符串函数

1.1 字符串变量补

int main(int argc,char const *argv[]) {int i = 0;char* s = "hello world";//s[0] = 'b';错误char* s2 = "hello world";printf("%s\n", s);printf("i=%p\n", &i);printf("s=%p\n", s);printf("s2=%p\n", s2);printf("here,s[0]=%c\n", s[0]);//S,S2地址一样，I【本地变量】和S不在一个地方//S的地址很小，只读，代码端//实际上是CONST CHAR*Schar s3[]= "hello world";printf("s3=%p\n", s3);printf("i=%p\n", &i);s3[0] = 'b';printf("%s\n", s3);//可以修改return 0;
}

指针还是数组，CHAR* S CHAR S[ ]
指针——1，反正就是用来输出一下，2，作为函数参数，3，分配动态空间【空间是MALLOC得到的，肯定是指针？？】

1.3 字符串输入输出补

#include<stdio.h>
int main(int argc,char const *argv[]) {char word[8];char word2[8];scanf("%s", word);scanf("%s", word2);printf("%s##\n%s##\n", word, word2);//SV不行，回车和空格都是间隔符，和TAB //越界危险char aa[8];scanf("%7s", aa);printf("%s##\n", aa); //最多读7个东西 ，剩下的给下一个%s? return 0;
}

常见错误：1，不初始化指针直接使用，CHAR*STRING,
2, 空字符串，char buttur[]="";=='\0\ ，长度只有1

呵呵，我不知道，并且没看懂顶楼大神的高清图，大柳树下，互联网大哥的图

Edge Image Viewer (baidu.com)

1.4 字符串数组

#include<stdio.h>
int main() {//cha**a ——》A是一个指针，指向另一个指针，这个指针指向一个字符（串）//char a[][]//第二维一定要有确定的值//a[0] ——》char[10],此时需要注意每一个字符串的长度char a[][10] = {"hello","word","weewdfwegweh"//太长了};return 0;
}

#include<stdio.h>
int main() {//a[0]——》char*char *a[] = {"hello","word","weewdfwegweh"};return 0;
}

1.2.1 月份

#include<stdio.h>
int main() {char* mouth[] = {"januaray","february","march","april","may","june","july","august","september","october","november","december",};int i = 0;scanf_s("%d", &i);printf("%s\n", mouth[i - 1]);return 0;
}

1.2.2 程序参数

#include<stdio.h>
int main(int argc, char const* argv[]) {//两个参数，整数，字符串数组//整数告诉我们字符串数组有多大，数组带入函数需要另一个参数告诉大小int i;for (i = 0; i < argc; i++) {printf("%d:%s\n", i, argv[i]);}//什么？0:.a.out，跟上点东西？会被ARGC ARGV读到//第一个函数，就是ARGC的0，就是执行的时候读到的命令的名字//或者说输入的可执行文件的名字 return 0;
}

不能说毫不相干，只能说南辕北辙，但是突然发现这个是文件的保存地址……啊啊啊
啊啊啊啊啊啊啊啊啊啊啊啊没懂

1.2.3 BUSY BOX 没懂

……………………搜了扫两眼

1.5 PUTCHAR & GETCHAR

#include<stdio.h>
int main()
{	int ch;while((ch=getchar())!=EOF){putchar(ch); }printf("EOF\n");return 0;
}

#include<stdio.h>
int main(int argc, char const* argc[])
//运行不了，会说const char**与int的间接寻址级别不同？
//打错字了而已，char const*argv[]//putchar会把一个字符输出在标准输出上，但是输入的类型是INT类型
//返回的类型也是INT，成功返回1，失败EOF（宏，值是-1）//getchar返回从标准输入读到的一个字符，类型也是INT
//通过返回EOF表示标准输入结束了
{int ch;while ((ch = getchar()) != EOF) {putchar(ch);}//输入一个值，读到的如果不是EOF，输出CHprintf("EOF\n");return 0;
}
//输入ctrl d结束了，但是没有输出EOF，只是强制循环结束，没有正确的让他知道，输入结束了
//继续输入还是可以进入循环，就是？没有进行下一步？
//输入CTRL Z，输入结束了，运行到了下一个语句？
//UNIC?需要输入CTRL D

行编辑，缓冲区，SHELL?大概就是两个命令就是不一样吧

二，字符串函数的实现

STRLEN，返回字符串长度
STRCMP，比较大小
STRCPY，拷贝
STRCAT，连接
STRCHAR，寻找一个字符
STRSTR，寻找一个字符串

2.1 STRLEN 长度

返回字符串长度

#include<stdio.h>
#include<string.h>//写一个代替STRLEN，遍历字符串，知道读到最后的0，结束
int mylen(const char* s) {int idx = 0;while (s[idx]!='\0') {idx++;}return idx;//没有就0了哦
}int main() {//strlen size_t strlen(const char*s)//返回S的字符串长度（不包括结尾的0(\n),SIZEOF包括//传入函数数组和指针是一样的，所以用指针表示了？//CONST不希望修改数组，不修改字符串char line[] = "hello";printf("strlen=%lu\n", strlen(line));printf("sizeof=%lu\n", sizeof(line));printf("mylen=%lu\n", mylen(line));
//5 6return 0;
}

2.2 STRCMP 比较

比较字符串大小
两种思路，数组思路，指针思路，编译器会做优化，可能会差不多？

#include<stdio.h>
#include<string.h>//挨个字符对比，知道都是\0,还是相等，则相等
int mycmp(const char*s1,const char*s2) {int idx = 0;while (1) {if (s1[idx] != s2[idx]) {break;}else if (s1[idx] == '\0') {break;}idx++;//都没有出现，继续下一个比较}return s1[idx]-s2[idx];//返回差值
}int mycmp1(const char* s1, const char* s2) {int idx = 0;while (s1[idx] == s2[idx] && s1[idx] != '\0') {idx++;}return s1[idx] - s2[idx];
}int mycmp2(const char* s1, const char* s2) {while (*s1 == *s2 && *s1 != '\0') {*s1++;*s2++;}//注意是不等于‘/-’return *s1 - *s2;
}int main(int argc,char const *argv[]) {char s1[] = "abc";char s2[] = "abc";printf("%d\n", strcmp(s1,s2));//0.相等表示0//if (strcmp(s1, s2) == 0) ，注意，相等的结果是0，不能直接作为判断条件//S1==S2 这个比较永远FAULT，因为这个比较是他们是否是相同的地址，两个变量的地址永远不相同char s3[] = "bbc";printf("%d\n", strcmp(s1, s3));//-1,S3>S1，比他大，因为A在字母表前面，B在字母表后面，所以A小char s4[] = "Abc";printf("%d\n", strcmp(s1, s4));printf("%d\n", 'a' - 'A');printf("%d\n", mycmp(s1, s4));//32//男神的是32 32 ，我的是1 32，男神说不相等的时候，给出的是两个的差值？？//差值就是返回值char s5[] = "abc ";printf("%d\n", strcmp(s1, s5));//-1,男神的是32！！！啊啊啊啊为什么！printf("%d\n", mycmp(s1, s5));//MYCMP输出的是-32！printf("%d\n", mycmp1(s1, s5));printf("%d\n", mycmp2(s1, s5));return 0;
}

2.3 STRCPY 拷贝

拷贝字符串
编译器会把打码优化，所以不用强求自己一定把代码写成那样子……while (*dst = *src)；一个空循环

//char*strcpy(char*restrict dst,const char*restrict src);
// (目的，源）（det,src)
//return dst;再参与其他计算//char* sdt = (char*)malloc(strlen(src) + 1);
// strcpy(dst,src);
//动态分配，申请一块内存把某个位置的字符串复制过来，
//只包括字符的长度，不包括‘\0’的结尾的长度，还要加一!!!

#include<stdio.h>
#include<string.h>char* mycpy(char* dst, const char* src) {int idx = 0;while(src[idx]){dst[idx] = src[idx];idx++;}//=0的时候出循环了，所以0没有写进去dst[idx] = '\0';return dst;
}
//优化，src[idx]!='\0'——》src[idx]:不是0就进入循环char* mycpy1(char* dst, const char* src) {while (*src != '\0') {*dst++ = *src++;}*dst = '\0';return dst;
}char* mycpy2(char* dst, const char* src) {while (*dst = *src);* dst = '\0';return dst;
}int main(int argc,char const *argv[]) {char s1[] = "bbc";char s2[] = "abc";strcpy(s1, s2);//用于调用的参数太少？printf("%s\n",s1);return 0;
}

2.4 STRCHR 查询

//char* strchr(const char*s,int c)
//char* strrchr(const char*s,int c)//从左边数第一次C出现的位置，返回的时指针
//从右边开始
//返回NULL，没找到，非NALL，找到了

#include<stdio.h>
#include<string.h>
#include<stdlib.h>int main(int argc,char const *argv[]) {char s[] = "hello";char* p = strchr(s, 'l');printf("%s\n", p);//LLO,返回一个指针，把后面的东西当作一个字符串输出，LLO//找第二个，LOp = strchr(p + 1, 'l');printf("%s\n", p);//找到之后把后面的东西复制出来char* t = (char*)malloc(strlen(p) + 1);strcpy(t, p);printf("%s\n", t);free(t);//输出L之前的东西char c=*p;//c=l *p='\0';//找到的第二个L,*p=0；char* t1=(char*)malloc(strlen(s)+1);//S所指的字符串就只有HEL了 strcpy(t1,s);//拷出来 printf("%s\n", t1);free(t1);*p='l';//不要忘记写回去 return 0;
}

char* strchr(const char* s,int c)
// 寻找单个字符
char* strstr(const char* s1,const char* s2)
// 寻找一个字符串
char* strcasestr(const char* s1,const char* s2)
//寻找的时候忽略大小写

2.5 STRCAT 连接补

天杀的，看到这里才发现不对！！！！我要闹了，我都以为学完要关电脑了！！！原来时MOOC23年的那个C程序设计进阶不全，还得看14年的！啊啊啊啊我说怎么字符串开头就如此生硬，就突然就讲了！！！！
连着字符串的内容都要补！！我要闹了！！！
呵呵呵，笑发财，本小白刚知道字符数组和字符串

我！就！说！今天怎么学的懵懵懂懂的！！！啊啊啊啊

#include<stdio.h>
#include<string.h> 
int mycat(char*a,const char*b){int i=0;for(i=0;a[i]!='\0';i++);int t=0;for(t=0;a[t]!='\0';t++);int s=0;for(s=0;s<=t;s++){a[i]=b[s];s++;i++;}return *a;
} 
int main(int argc, char const* argv[]) {//char* strcat(char*restrict s1,const char*restrict s2);//把S2拷贝到S1的后面 //S1必须有足够的空间 char a[]="halllo  ";char b[]="byebye";strcat(a,b);printf("%s\n",a);mycat(a,b);printf("%s\n",a);return 0;
}

STRCPY和STRCAT都有安全问题，空间不足！

char* strncpy(char* restrict dst, cosnt char* restrict src, size_t n);
char* strncat(char* restrict s1, const char* restrict s2, size_t n);
int strncmp(const char* s1, const char* s2, size_t n);能够CPY，CAT多少字符，多了就掐掉
对于CMP是，只比较前面N个字符

结束！！！我真的麻了