C---字符串

补习（这种写法不熟悉）

int main()
{
    char *str = "hhhhhhhhhhh\n";
    printf("%s",str);
    
    int *a = 10;
    printf("a=%d\n",a);
    
	return 0;
}   
1
2
3
4
5
6
7
8
9
10

%s通过‘\0’来结束输出

字符串的存储方式：

1.字符串在内存中，除了有效字符以外，还会自动在后面补一个‘\0’
作为字符串的结束标志

 
    char a3[] = "abc";
    printf("字符数组的大小：%d\n",sizeof(a3));
    printf("字符数组的元素大小：%d\n",sizeof(a3[0]));
    printf("字符数组的个数：%d\n",sizeof(a3)/sizeof(a3[0]));  

1
2
3
4
5
6

2.真正计算有效字符的长度用strlen
例如在做网络通信时，获取的消息有乱码；协议两端不匹配。都有可能是字符串的问题（没用strlen用了sizeof）

3.strlen的原理是遇到\0就停止计数，比如一个字符串abc\0dfg
输出该字符串的大小也是3（取\0前的部分）

例题：

printf不乱码和乱码的原因：
arr1在内存中存放abc后会自动补一个\0作为字符串结束的标志。
arr2存放完abc后不会补\0，就没有结束标志。
在printf时，遇到结束标志就不在打印以后的内容，如果没有结束标志就会继续打印（打印的内容是内存中其他的一些东西，具体是什么我们不知道，表现出来的就是乱码）。

字符串几种常用API

1.puts

效果同printf，puts会自动加个换行

2.gets （同scanf）

1.先说一下 char str[128]={‘\0’}和char *pstr的区别

char str[128] = {‘\0’}；
在内存中申请了连续的128个字节，并且每一项都是\0
1
2

char *pstr;
定义了一个指针，存放的是别人的地址，是野指针，会出现段错误，cmd窗口闪退
1
2

野指针问题：（NULL是谁都不指，没有NULL是瞎指）
所以，不知道指针指向哪块内存就操作内存的东西不行
2.

char *pstr = NULL;
     pstr = (char *)malloc(128); //定义数组的方式来定义字符串
     printf("请输入字符串\n");
     gets(pstr);

     printf("输入的是：%s\n",pstr);
1
2
3
4
5
6

3.ets能读取回车（跟读字符一样），scanf()不能

3. memset

memset(初始化谁，初始化成什么，这个谁多大）初始化函数

4. 拷贝 strcmp和strncpy

char newsrc[128] = {'\0'};
char *oldsrc = "啊哈哈哈";

strcpy(newsrc,oldsrc);
printf("复制后的newstr=%d\n",newstr);

1
2
3
4
5
6

5.拼接 strcat

先说一下编程中遇到的问题：

int main()
{
    
     char *strsrc = "啊哈哈哈";
     strsrc = (char	 *)malloc(128);//加上这句话，拼接时啊哈哈哈会乱码；不加就能正常拼接
   
     char strc[128] = "嘿嘿嘿";
     strcat(strc,strsrc);
     puts(strc);
	
    
    system("pause");
	return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

原因是：首先要知道malloc做了什么：
malloc()函数在内存中找一片指定大小（128个字节）的空间，然后将这个空间的首地址范围给一个指针变量（strsrc）。
本来在内存中申请了地址空间给”啊哈哈哈“，malloc之后，把地址改成128个字节的连续空间的首地址了，之前的地址作废了，”啊哈哈哈“也没了，所以指向个新地址，新地址啥也没有，自然乱码。

6. 比较 strcmp

比较两个字符串：strcmp(const char *s1,const char *s2);

如果返回值 < 0，则表示 s1 小于 s2。
如果返回值 > 0，则表示 s1 大于 s2。
如果返回值 = 0，则表示 s1 等于 s2。

7.strchr

功能：显示你要找的字符及其后面的内容
返回值是个指针（指向该字符串中第一次出现的字符的指针）

如果没找到就显示请按任意键继续（啊哈C），其他的某些编译环境可能会崩溃

8.查找子串strstr

功能：检索子串在字符串中首次出现的位置
char *strstr(char *str,char *substr);
str:是要检索的字符串
substr：要检索的子串

功能与上面的strchr一样，区别就是strchr找的是字符，strstr找的是字符串。

9.strlwr 把字符串转为小写

strupr 把字符串转为大写

10.strtok字符串分割

如果只分割一次，调用一次strtok即可，
分割多次，就要分割几次调用几次strtok

自己实现字符串的操作

面试时笔试题可能会让你写一个strcpy（memset/strlen等等）的源码

1.实现puts

void myputs(char *p)
{
    //利用字符串结尾有'\0'的特点
    while(*p!='\0'){    //一直取内容，取到结尾\0时停止。（此处的*p是取内容的意思，不是定义指针）
    putchar(*p++);        
    }  
     putchar('\n');  
}

int main()
{
	char *p = "自己实现字符串";
    
    myputs(p);
    
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.实现gets

int mygets(char *p)
{
     int cnt = 0;
     while(*p = getchar()){           //getchar()是用来获取内容的
          if(*p == '\n'){
             return cnt; //输入的是回车就不往下走了  把cnt提出 来      (此处修改一下，看下个代码片)
          }else{
             p++ ;   //否则p往下走         
          }
     }
}

int main()
{
    char str[128] = {'\0'}; //定义一个字符数组，每一项都是0
    printf("请输入字符串\n");
    int cnt = mygets(str);
    puts(str); 
    printf("cnt = %d：\n",cnt);
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

运行结果：

while(*p = getchar()){
          if(*p == 'a'){
             return ; //输入的是a就不往下走了        
          }
1
2
3
4

运行结果：

所以*p == 'a’这句的作用不是在输入字符串输到a就不能继续输入了，而是输出到a时就不往下输出了。

3.实现strlen

int  mystrlen(char *str)
{
    int cnt = 0;
     while(*str++!='\0'){
         cnt++;  
     }    
     return cnt;
      puts('\n');
}

int main()
{
    char str[128] = {'\0'};
    printf("请输入字符串\n");
    gets(str);
    printf("cnt = %d\n",mystrlen(str));
    puts(str);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行效果：

4.memset

void mymemset(char *p,char c, int size) // 要初始化的字符，初始化成谁，初始化大小
{
    while(size--){        
        *p++ = c;    //指针一项一项往后移，每一项都等于c

    }  
}

int main()
{
    char *str = NULL;
    
    str = (char *)malloc(128);
    mymemset(str,'a',10);
    str[128] = '\0';
    puts(str); 
    
    char *p = "hahahahhahha";
    printf("长度 = %d\n",strlen(p));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果：

5.strcpy

char *mystrcpy(char *test,const char *src)
{
    while(*src!='\0'){
         *test = *src;
         test++;
         src++;    
    }
      return test;
}

int main()
{
   
   char test[128] = {'\0'};
   
   char *src ="okokok";
   
   mystrcpy(test,src);
   
   puts(test);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行效果：okokok

6.strncpy

char *mystrncpy(char *test,const char *src,int n)
{
    while(*src!='\0' && n>0){     //加一个n>0的条件
         *test = *src;
         test++;
         src++;    
         n--;       //拷贝一个，n-一次
    }
      return test;
}

int main()
{
   
   char test[128] = {'\0'};
   
   char *src ="okokokok ";
   
   mystrncpy(test,src,2);    //只拷贝两个
   
   puts(test);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：ok

7.strcat

void mystrcat (char *dest , char *src)
{
      while(*dest != '\0'){
           dest++;     //一直往后移，移到字符串的尾巴      
       
      }
       while(*src != '\0'){
           *dest++ =  *src++;          //把src里的东西拷贝给dest,从尾巴开始拷贝
       
      }
      *dest = '\0';
}

int main()
{
   
   char dest[128] = "heiheihei ";
   
   char *src ="hahaha";
   
   mystrcat(dest,src);
   
   puts(dest);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行结果：heiheihei hahaha

剩下的字符串自己写