C语言中的字符串操作函数

本文转载自微信公众号「编码珠玑」，作者刘亚曦。转载本文请联系编码珠玑公众号。

成都创新互联长期为1000+客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为崇信企业提供专业的成都网站制作、成都做网站，崇信网站改版等技术服务。拥有十年丰富建站经验和众多成功案例,为您定制开发。

我们知道，c/c++之所以使用起来灵活，很大原因归因于它能够它对能够对内存的直接操作，所以本文我主要讲述一下c中的字符串操作函数。

一、常量指针与指针常量

先来补充一个上篇文章 手把手教你深入理解c/c++中的指针 我在讲述指针中的一个问题，有人说常量指针与指针常量这两个概念总是混淆怎么办，例如：

 
 
 
 
    
  
  
  
  
  1. int a = 100;
    2. 
  
  
  
  
  2. const int * p = &a;  //常量指针，指向的值不可更改，但指向的地址可以更改
    3. 
  
  
  
  
  3. int const * p = &a;  //与上式等价
    4. 
  
  
  
  
  4. int * const p = &a;  //指针常量，指向的地址不可以更改，但指向的值可更改
    5.

那么究竟如何区分常量指针与指针常量呢，这里边有个技巧，上篇文章中我忘记给大家说了：

从左往右看，跳过类型，看修饰哪个字符，如果是*， 说明指针指向的值不能改变，如果是指针变量，说明指针的指向不能改变，指针的值不能修改。这个原则你可以通俗理解成 “就近原则”。

那么回头来看第一行代码，也就是指针常量：

 
 
 
 
    
  
  
  
  
  1. const int * p = &a;
    2.

我们跳过变量类型 int ，那么const修饰的是*，所以它指向的值不能修改

第二行代码，常量指针：

 
 
 
 
    
  
  
  
  
  1. int * const p = &a;
    2.

同样，我们跳过int，发现const是直接修饰的p，所以它的指向不能改变。两者有细微的差别，请大家注意。

我们再回到本节的字符串问题上，在讲述字符串拷贝函数前，我们再来回忆一下c语言中的字符串。

我们知道，c语言中的字符串有两种定义的方法，分别是：

 
 
 
 
    
  
  
  
  
  1. char str1[] = "hello world";  //栈区字符串
    2. 
  
  
  
  
  2. char* str2 = "hello world";  //数据常量区字符串
    3.

那么这两种在使用起来究竟有什么区别呢?答案是第一行定以后，操作系统给它分配的是栈区内存，而第二行通过指针形式来定义字符串的话，它分配的内存区在数据的常量区，意味着它的值是不可更改的：

 
 
 
 
    
  
  
  
  
  1. str1[0] = 'm';  //正确，字符数组可以修改
    2. 
  
  
  
  
  2. str2[0] = 'm';  //错误，常量区不可修改
    3.

所以，在常量区，如果我们两个内容相同但变量不同的指针变量，其实它们指向的是同一块内存：

 
 
 
 
    
  
  
  
  
  1. char* str1 = "hello world";  
    2. 
  
  
  
  
  2. char* str2 = "hello world";  
    3. 
  
  
  
  
  3. printf("%p\n",str1);
    4. 
  
  
  
  
  4. printf("%p\n",str2);
    5.

上面两行代码中，我们将str1与str2指向的内存地址分别打印出来，发现他们的值是一样的，为什么呢，这是因为常量区内存的值是只读的，我们即便声明两个不同的变量，只要他们的值是相同的，那么两个变量指向的就是同一块内存区域。

这里值得注意的是，在c++中，字符串指针与c语言中稍有区别，c++中直接将字符串指针做了增强处理，因为c++中规定字符串指针必须用const修饰，例如在c++中这样定义，编译器会直接报错：

 
 
 
 
    
  
  
  
  
  1. char* str = "hello world";  //直接报错
    2. 
  
  
  
  
  2. const char * str = "hello world";  //正确
    3.

而在实际开发过程中，我们使用字符串一般使用数组形式，不太建议使用指针字符串形式，也即：

 
 
 
 
    
  
  
  
  
  1. char str[] = "hello world";  //建议使用
    2. 
  
  
  
  
  2. char* str = "hello world";  //不建议使用
    3.

所以，这方面细微的差别请大家注意。

二、字符串长度问题

我们知道c语言中的字符串是以 '\0' 为结尾的，也就是说你在声明一个字符串的时候，系统会自动为你的结尾添加上一个以 '\0' 为结尾的结束字符，而且，printf 在每打印一个字符就会检查当前字符是否为 ‘\0’ ,直到遇到 '\0' 立马停止。这里最容易混淆的的是字符串的长度，我们来看下面两行代码：

我们先来看下面两行代码：

 
 
 
 
    
  
  
  
  
  1. char str1[] = "hello";
    2. 
  
  
  
  
  2. char* str2 = "hello";
    3. 
  
  
  
  
  3. printf("%d\n", sizeof(str1));  //输出结果为 6
    4. 
  
  
  
  
  4. printf("%d\n", sizeof(str2));  //输出结果为 4 或者 8
    5.

那么为什么在使用 sizeof 计算字符串长度，两者计算出来的结果不一样呢，而且第一行长度还不是我们想要的，不应该是 5 才对吗?这是因为在声明一个字符串的时候，系统会自动为你的结尾添加上一个以 '\0' 为结尾的结束字符，内存模型如下：

所以，对于上面两行代码，实际上它们的长度都为 6 才对。那为什么第二行输出却为 4 呢，这是因为第二行我们定义的是一个字符串指针，它指向一个常量区的字符串，而 sizeof 操作符操作这个指针的时候，实际上计算的是这个指针的字节长度，而一个指针在x86系统下占有长度为 4 字节，在x64环境下占有长度为 8 字节，所以，在实际上我们计算字符串长度的时候，一般会用 strlen() 这个函数，但是要注意，strlen 计算字符串也是以 '\0' 为结束的，也就是说，strlen() 函数会不断判断当前字符是否为 '\0'，如果是的话，立马结束，这个特点与printf函数一样，两者都是碰到 '\0' 就立马结束：

 
 
 
 
    
  
  
  
  
  1. char str1[] = "abc";
    2. 
  
  
  
  
  2. char str2[] =  {'a', '\0', 'c'};
    3. 
  
  
  
  
  3. char str3[] =  {'a', 'b', 'c', '\0'};
    4. 
  
  
  
  
  4. char* str4 = "abc";
    5. 
  
  
  
  
  5. printf("%d\n", strlen(str1));  //输出结果为 3
    6. 
  
  
  
  
  6. printf("%d\n", strlen(str2));  //输出结果为 1
    7. 
  
  
  
  
  7. printf("%d\n", strlen(str3));  //输出结果为 3
    8. 
  
  
  
  
  8. printf("%d\n", strlen(str4));  //输出结果为 3
    9.

上面就是c语言中的字符串长度函数，在使用过程中千万要注意。

三、C语言中的字符串拷贝函数

1) strcpy()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. char *strcpy(char *dest, const char *src);
    3. 
  
  
  
  
  3. //功能：把src所指向的字符串复制到dest所指向的空间中，'\0'也会拷贝过去
    4. 
  
  
  
  
  4. 参数：
    5. 
  
  
  
  
  5.   dest：目的字符串首地址
    6. 
  
  
  
  
  6.   src：源字符首地
    7. 
  
  
  
  
  7. 返回值：
    8. 
  
  
  
  
  8.   成功：返回dest字符串的首地址
    9. 
  
  
  
  
  9.   失败：NULL
    10.

示意代码如下：

 
 
 
 
    
  
  
  
  
  1. #define _CRT_SECURE_NO_WARNINGS
    2. 
  
  
  
  
  2.   #include 
    3. 
  
  
  
  
  3.   char str[10] = { 0 };
    4. 
  
  
  
  
  4.   char str1[] = "hello";
    5. 
  
  
  
  
  5.   char* mystr = strcpy(str, str1);  将strcpy返回的指针保存到mystr里面
    6. 
  
  
  
  
  6.   printf(mystr);
    7.

内存模型如下：

由于是逐个拷贝，意味着哪怕在字符串的中间遇到了 '\0' 字符，也会结束拷贝。

这里边要注意两个问题：第一，必须保证 dest 所指向的内存空间足够大，否则可能会造成缓冲溢出的错误;第二，由于本身strcpy函数是一个非安全函数，所以编译器会弹出警告，要想忽略，请在程序最开头添加宏定义代码：

 
 
 
 
    
  
  
  
  
  1. #define _CRT_SECURE_NO_WARNINGS
    2.

2)strncpy()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. char *strncpy(char *dest, const char *src, size_t n);
    3. 
  
  
  
  
  3. 功能：
    4. 
  
  
  
  
  4.   把src指向字符串的前n个字符复制到dest所指向的空间中，
    5. 
  
  
  
  
  5.   是否拷贝结束符看指定的长度是否包含'\0'。
    6. 
  
  
  
  
  6. 参数：
    7. 
  
  
  
  
  7.   dest：目的字符串首地址
    8. 
  
  
  
  
  8.   src：源字符首地址
    9. 
  
  
  
  
  9.   n：指定需要拷贝字符串个数
    10. 
  
  
  
  
  10. 返回值：
    11. 
  
  
  
  
  11.   成功：返回dest字符串的首地址
    12. 
  
  
  
  
  12.   失败：NULL
    13.

这个函数与strcpy类似，这里不再累赘。

3)strcat()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. char *strcat(char *dest, const char *src);
    3. 
  
  
  
  
  3. 功能：将src字符串连接到dest的尾部，‘\0’也会追加过去
    4. 
  
  
  
  
  4. 参数：
    5. 
  
  
  
  
  5.   dest：目的字符串首地址
    6. 
  
  
  
  
  6.   src：源字符首地址
    7. 
  
  
  
  
  7. 返回值：
    8. 
  
  
  
  
  8.   成功：返回dest字符串的首地址
    9. 
  
  
  
  
  9.   失败：NULL
    10.

这是一个字符串追加函数，将 src 指向的字符串追加到 dest 指向的字符串后面，同样，结束符 '\0' 也会追加过去：

 
 
 
 
    
  
  
  
  
  1. #define _CRT_SECURE_NO_WARNINGS
    2. 
  
  
  
  
  2.   #include 
    3. 
  
  
  
  
  3.   char str[] = "123";
    4. 
  
  
  
  
  4.   char str1[] = "hello";
    5. 
  
  
  
  
  5.   char* mystr = strcat(str, str1);
    6. 
  
  
  
  
  6.   printf("%s\n%p", mystr, mystr);  
    7. 
  
  
  
  
  7.   //输出结果为：123hello
    8.

但是同样注意的是，目标字符串 dest 要有足够大的缓冲区来接收，否则会报错，内存模型如下：

4)strncat()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. char *strncat(char *dest, const char *src, size_t n);
    3. 
  
  
  
  
  3. 功能：将src字符串前n个字符连接到dest的尾部，‘\0’也会追加过去
    4. 
  
  
  
  
  4. 参数：
    5. 
  
  
  
  
  5.   dest：目的字符串首地址
    6. 
  
  
  
  
  6.   src：源字符首地址
    7. 
  
  
  
  
  7.   n：指定需要追加字符串个数
    8. 
  
  
  
  
  8. 返回值：
    9. 
  
  
  
  
  9.   成功：返回dest字符串的首地址
    10. 
  
  
  
  
  10.   失败：NULL
    11.

这个函数与strcat类似，只不过指定了追加的数量。

5)strcmp()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. char *strcat(char *dest, const char *src);
    3. 
  
  
  
  
  3. 功能：将src字符串连接到dest的尾部，‘\0’也会追加过去
    4. 
  
  
  
  
  4. 参数：
    5. 
  
  
  
  
  5.   dest：目的字符串首地址
    6. 
  
  
  
  
  6.   src：源字符首地址
    7. 
  
  
  
  
  7. 返回值：
    8. 
  
  
  
  
  8.   成功：返回dest字符串的首地址
    9. 
  
  
  
  
  9.   失败：NULL
    10.

作用是对两个字符串的ASCII码进行比较，输出不同结果，经常用于判断两个字符串是否相等，示例代码如下：

 
 
 
 
    
  
  
  
  
  1. char *str1 = "hello world";
    2. 
  
  
  
  
  2. char *str2 = "hello mike";
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. if (strcmp(str1, str2) == 0)
    5. 
  
  
  
  
  5. {
    6. 
  
  
  
  
  6.   printf("str1==str2\n");
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. else if (strcmp(str1, str2) > 0)
    9. 
  
  
  
  
  9. {
    10. 
  
  
  
  
  10.   printf("str1>str2\n");
    11. 
  
  
  
  
  11. }  
    12. 
  
  
  
  
  12. else
    13. 
  
  
  
  
  13. {
    14. 
  
  
  
  
  14.   printf("str1
  
  
  
  
  15. }
    16.

6)strncmp()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. int strncmp(const char *s1, const char *s2, size_t n);
    3. 
  
  
  
  
  3. 功能：比较 s1 和 s2 前n个字符的大小，比较的是字符ASCII码大小。
    4. 
  
  
  
  
  4. 参数：
    5. 
  
  
  
  
  5.   s1：字符串1首地址
    6. 
  
  
  
  
  6.   s2：字符串2首地址
    7. 
  
  
  
  
  7.   n：指定比较字符串的数量
    8. 
  
  
  
  
  8. 返回值：
    9. 
  
  
  
  
  9.   相等：0
    10. 
  
  
  
  
  10.   大于：> 0
    11. 
  
  
  
  
  11.   小于： < 0
    12.

这个函数作用也是与strcmp类似，不再累赘。

7)sprintf()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. int sprintf(char *str, const char *format, ...);
    3. 
  
  
  
  
  3. 功能：根据参数format字符串来转换并格式化数据，
    4. 
  
  
  
  
  4.       然后将结果输出到str指定的空间中，
    5. 
  
  
  
  
  5.       直到出现字符串结束符 '\0' 为止。
    6. 
  
  
  
  
  6. 参数：
    7. 
  
  
  
  
  7.   str：字符串首地址
    8. 
  
  
  
  
  8.   format：字符串格式，用法和printf()一样
    9. 
  
  
  
  
  9. 返回值：
    10. 
  
  
  
  
  10.   成功：实际格式化的字符个数
    11. 
  
  
  
  
  11.   失败： - 1
    12.

示例代码如下：

 
 
 
 
    
  
  
  
  
  1. char dst[100] = { 0 };
    2. 
  
  
  
  
  2.   int a = 10;
    3. 
  
  
  
  
  3.   char src[] = "hello";
    4. 
  
  
  
  
  4.   int len = sprintf(dst, "a=%d, src=%s", a, src);
    5. 
  
  
  
  
  5.   printf("dst: %s\n", dst);  输出 a=10,src=hello
    6. 
  
  
  
  
  6.   printf("len = %d\n", len);  输出14
    7.

下面再介绍几个字符串操作函数，但这几个使用频率比较小：

8) sscanf()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. int sscanf(const char *str, const char *format, ...);
    3. 
  
  
  
  
  3. 功能：从str指定的字符串读取数据，
    4. 
  
  
  
  
  4.   并根据参数format字符串来转换并格式化数据。
    5. 
  
  
  
  
  5. 参数：
    6. 
  
  
  
  
  6.   str：指定的字符串首地址
    7. 
  
  
  
  
  7.   format：字符串格式，用法和scanf()一样
    8. 
  
  
  
  
  8. 返回值：
    9. 
  
  
  
  
  9.   成功：参数数目，成功转换的值的个数
    10. 
  
  
  
  
  10.   失败： - 1
    11.

示例代码：

 
 
 
 
    
  
  
  
  
  1. char src[] = "a=10, b=20";
    2. 
  
  
  
  
  2.   int a;
    3. 
  
  
  
  
  3.   int b;
    4. 
  
  
  
  
  4.   sscanf(src, "a=%d,  b=%d", &a, &b);
    5. 
  
  
  
  
  5.   printf("a:%d, b:%d\n", a, b);
    6. 
  
  
  
  
  6.   输出：a:20,b:20
    7.

sscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源。

9) strchr()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. char *strchr(const char *s, char c);
    3. 
  
  
  
  
  3. 功能：在字符串s中查找字母c出现的位置
    4. 
  
  
  
  
  4. 参数：
    5. 
  
  
  
  
  5.   s：字符串首地址
    6. 
  
  
  
  
  6.   c：匹配字母(字符)
    7. 
  
  
  
  
  7. 返回值：
    8. 
  
  
  
  
  8.   成功：返回第一次出现的c地址（注意是地址，不是字符数组索引）
    9. 
  
  
  
  
  9.   失败：NULL
    10.

示例代码：

 
 
 
 
    
  
  
  
  
  1. char src[] = "ddda123abcd";
    2. 
  
  
  
  
  2. char *p = strchr(src, 'a');
    3. 
  
  
  
  
  3. printf("p = %s\n", p);
    4. 
  
  
  
  
  4. 输出：p=a123abcd
    5.

10)strstr()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. char *strstr(const char *haystack, const char *needle);
    3. 
  
  
  
  
  3. 功能：在字符串haystack中查找字符串needle出现的位置
    4. 
  
  
  
  
  4. 参数：
    5. 
  
  
  
  
  5.   haystack：源字符串首地址
    6. 
  
  
  
  
  6.   needle：匹配字符串首地址
    7. 
  
  
  
  
  7. 返回值：
    8. 
  
  
  
  
  8.   成功：返回第一次出现的needle地址
    9. 
  
  
  
  
  9.   失败：NULL
    10.

这个函数与上一个 strchr 功能类似，只不过查找的内容是字符串，而非字单个字符。

11) strtok()

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. char *strtok(char *str, const char *delim);
    3. 
  
  
  
  
  3. 功能：将字符串分割成一个个片段, 
    4. 
  
  
  
  
  4.       当strtok()在参数str的字符串中发现参数delim中包含的分割字符时, 
    5. 
  
  
  
  
  5.       则会将该字符改为\0 字符，当连续出现多个时只替换第一个为\0，
    6. 
  
  
  
  
  6.       该函数会破坏原有字符串。
    7. 
  
  
  
  
  7. 参数：
    8. 
  
  
  
  
  8.   str：指向欲分割的字符串
    9. 
  
  
  
  
  9.   delim：为分割字符串中包含的所有字符
    10. 
  
  
  
  
  10. 返回值：
    11. 
  
  
  
  
  11.   成功：分割后字符串首地址
    12. 
  
  
  
  
  12.   失败：NULL
    13.

示例代码：

 
 
 
 
    
  
  
  
  
  1. char a[100] = "www.baidu.com";
    2. 
  
  
  
  
  2. char *p = strtok(a, ".");
    3. 
  
  
  
  
  3. while (p != NULL)
    4. 
  
  
  
  
  4. {  
    5. 
  
  
  
  
  5.   printf("%s\n", p);  
    6. 
  
  
  
  
  6.   p = strtok(NULL, ".");
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. 输出：www baidu com
    9.

以上，就是本文的全部内容了。

新闻名称：C语言中的字符串操作函数
文章路径：http://www.hantingmc.com/qtweb/news5/545155.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

App开发知识

分类信息网站

合江网站建设　　 　外贸营销网站建设　　 　网站建设费用　　 　成都网页设计　　 　成都康明斯发电机　　 　网站营销　　 　德阳机房　　 　成都IDC机房托管　　 　西信服务器托管　　 　百度推广公司　　 　成都网站改版　　 　雅安机房托管　　 　网络营销　　 　四川广汉锦华　　 　成都机柜租用　　 　犀浦防纹窗　　 　成都门窗定制　　 　谷歌推广　　 　网创优客　　 　蓬溪网站建设