【C语言】字符函数和字符串函数
目录
1.求字符串长度strlen
2.长度不受限制的字符串函数
字符串拷贝strcpy
字符串追加strcat
字符串比较strcmp
3.长度受限制的字符串函数介绍strncpy
strncat
编辑strncmp
4.字符串查找strstr
5.字符串分割strtok
6.错误信息报告
strerror
perror
7.字符分类函数
8.字符转换函数
9.内存操作函数
memcpy
memmove
memset
memcmp编辑
1.求字符串长度strlen
函数介绍
- 字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。
- 参数指向的字符串必须要以 '\0' 结束。
- 注意函数的返回值为size_t，是无符号的（ 易错 ）
使用示例
int main()
{size_t sz = strlen("abcd");printf("%u", sz);return 0;
}因为函数的返回值为无符号类型，所以对于下面这种代码，我们很容易就看错：
#include<stdio.h>
#include<string.h>
int main()
{if (strlen("abc") - strlen("abcdef") > 0){printf("大于\n");}else{printf("小于\n");}return 0;
}输出结果：
正确的比较方法：
if (strlen("abc") > strlen("abcdef"))strlen的模拟实现
size_t my_strlen(const char* str)
{int count = 0;while (*str!='\0'){count++;str++;}return count;
}
2.长度不受限制的字符串函数
字符串拷贝strcpy
- Copies the C string pointed by source into the array pointed by destination, including the terminating null character (and stopping at that point).
- 源字符串必须以 '\0' 结束。
- 会将源字符串中的 '\0' 拷贝到目标空间。
- 目标空间必须足够大，以确保能存放源字符串。
- 目标空间必须可变
使用示例
int main()
{char arr1[20] = { 0 };char arr2[] = "hello world";strcpy(arr1, arr2);printf("%s", arr1);return 0;
}输出结果： 
strcpy的模拟实现
char* my_strcpy(char* dest, const char* src)
{assert(dest && src);char* ret = dest;while (*dest++ = *src++){}return ret;
}字符串追加strcat
- Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination.
- 源字符串必须以 '\0' 结束。
- 目标空间必须有足够的大，能容纳下源字符串的内容。
- 目标空间必须可修改。
- 字符串自己给自己追加，如何？
使用示例
int main()
{char arr1[20] = "hello ";char arr2[] = "world";strcat(arr1, arr2);printf("%s", arr1);return 0;
}输出结果：
strcat的模拟实现
char* my_strcat(char* dest, const char* src)
{assert(dest && src);char* ret = dest;while (*dest != '\0')//找到目标空间的\0{dest++;}while (*dest++ = *src++){}return ret;
}注意：字符串不能自己给自己追加
当字符串自己给自己追加时，字符串中的'\0'将会被覆盖，导致程序陷入死循环。
字符串比较strcmp
- This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.
- 标准规定：
- 第一个字符串大于第二个字符串，则返回大于0的数字
- 第一个字符串等于第二个字符串，则返回0
- 第一个字符串小于第二个字符串，则返回小于0的数字
使用示例
int main()
{int ret1 = strcmp("abcdef", "abq");int ret2 = strcmp("abc", "abc");printf("%d\n", ret1);printf("%d\n", ret2);return 0;
}输出结果：
strcmp的模拟实现
int my_strcmp(const char* str1, const char* str2)
{assert(str1 && str2);while (*str1++ == *str2++){if (*str1 == '\0'){return 0;}}return *str1 - *str2;
}
3.长度受限制的字符串函数介绍
strncpy
- Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
使用示例
int main()
{char arr1[20] = "abcdef";char arr2[20] = "xxxxxxxxxxxxxx";strncpy(arr1, arr2, 3);printf("%s\n", arr1);return 0;
}输出结果：
strncat
- Appends the first num characters of source to destination, plus a terminating null-character.
- If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.
使用示例
int main()
{char arr1[20] = "hello ";char arr2[20] = "worldxxx";strncat(arr1, arr2, 5);printf("%s\n", arr1);return 0;
}输出结果：
strncmp
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
使用示例
int main()
{char arr1[20] = "abc";char arr2[20] = "abcdef";char arr3[20] = "aba";printf("%d\n", strncmp(arr1, arr2, 3));printf("%d\n", strncmp(arr1, arr2, 4));printf("%d\n", strncmp(arr1, arr3, 5));return 0;
}输出结果：
4.字符串查找strstr
strstr函数是在字符串str1中查找是否含有字符串str2，如果存在，返回str2在str1中第一次出现的地址；否则返回NULL。
使用示例
int main()
{char arr1[] = "abcdefabcdef";char arr2[] = "def";char* ret = strstr(arr1, arr2);if(ret!=NULL){printf("%s\n", ret);}return 0;
}输出结果：
strstr的模拟实现
这里使用的是BF算法来实现：
char* my_strstr(char* str1, char* str2)
{char* cp = str1;char* s1 = cp;char* s2 = str2;while (*cp){s1 = cp;s2 = str2;while (*s1 && *s2 && *s1 == *s2){s1++;s2++;}if (*s2 == '\0')return cp;cp++;}return NULL;
}
5.字符串分割strtok
- sep参数是个字符串，定义了用作分隔符的字符集合
- 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标 记。
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
- strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记，则返回 NULL 指针。
使用示例1
int main()
{char arr[] = "123@qq.com";char sep[] = "@.";char copy[20];strcpy(copy, arr);char* pc = strtok(copy, sep);while (pc){puts(pc);pc = strtok(NULL, sep);}return 0;
}使用示例2
int main()
{char arr[] = "123@qq.com";char sep[] = "@.";char copy[20];strcpy(copy, arr);char* ret = NULL;for (ret = strtok(copy, sep); ret != NULL; ret = strtok(NULL, sep)){printf("%s\n", ret);}return 0;
}输出结果：
6.错误信息报告
strerror
返回错误码，所对应的错误信息。
库函数在执行的时候，发生了错误会将错误码存放在errno这个全局变量中。errno是C语言提供的一个全局变量。
下面代码是将错误码0~9所对应的错误信息给打印出来：
int main()
{int i = 0;for (int i = 0; i < 10; i++){printf("%d:%s\n", i, strerror(i));}return 0;
}
当然，这里展示的仅仅是一小部分。
下面演示一下当我们进行文件操作是，打开文件失败后查找打开失败的原因：
int main()
{FILE* pf = fopen("data.txt", "r");if (pf == NULL){printf("%s\n", strerror(errno));}return 0;
}
程序输出了“ No such file or directory ”的错误提示，意思是没有要打开的文件。
perror
perror(str) 用来将上一个函数发生错误的原因输出到标准设备(stderr)。参数 str 所指的字符串会先打印出，后面再加上错误原因字符串。此错误原因依照全局变量errno的值来决定要输出的字符串。
使用示例
int main()
{FILE* pf = fopen("data.txt", "r");if (pf == NULL){printf("%s\n", strerror(errno));perror("fopen");}return 0;
} 输出结果：
7.字符分类函数
8.字符转换函数
下面代码的功能是输入一串字符，将字符串中的小写字母转成大写，大写字母转成小写
int main()
{char arr[30] = { 0 };gets(arr);char* p = arr;while (*p){if (isupper(*p)){*p = tolower(*p);}else if (islower(*p)){*p = toupper(*p);}*p++;}puts(arr);
}
9.内存操作函数
memcpy
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 '\0' 的时候并不会停下来。
- 如果source和destination有任何的重叠，复制的结果都是未定义的。
可以拷贝任意类型的数据：字符串，整形数组，结构体数据类型……
使用示例
int main()
{int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[20] = { 0 };//将arr1的内容拷贝到arr2中memcpy(arr2, arr1, 40);for (int i = 0; i < 20; i++){printf("%d ", arr2[i]);}return 0;
}输出结果：
memcpy的模拟实现
void* my_memcpy(void* dest, void* src, size_t num)
{assert(dest && src);void* ret = dest;while (num--){*(char*)dest = *(char*)src;dest = (char*)dest + 1;src = (char*)src + 1;}return ret;
}注意下面这种写法编译器会报错：
在代码中，使用了(char*)dest++和(char*)src++来更新指针的位置。然而，这种写法是不正确的，因为后缀递增操作符++的优先级高于类型转换操作符(char*)，所以实际上你只是在转换指针类型后递增了一个临时变量，而没有更新指针本身的值。
注意：mencpy 函数是用来处理不会重叠的内存拷贝，当我们拷贝两个相同的字符串是，可以结果与预期的会不相同：
int main()
{int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };my_memcpy(arr1+2, arr1, 32);for (int i = 0; i < 10; i++){printf("%d ", arr1[i]);}printf("\n");return 0;
}对于上面的代码，我们的预期结果是这样的：
实际输出的结果却是如下：
如果要拷贝重叠的内存，我们就要使用下面这个函数了
memmove
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
使用示例
int main()
{int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };memmove(arr1+2, arr1, 32);for (int i = 0; i < 10; i++){printf("%d ", arr1[i]);}printf("\n");return 0;
}输出结果：
memmove的模拟实现
不同于memcpy,mommove的拷贝需要分情况：
void* my_memmove(void* dest, const void* src, size_t num)
{assert(dest && src);void* ret = dest;if (dest < src){//从前向后拷贝while (num--){*(char*)dest = *(char*)src;dest = (char*)dest + 1;src = (char*)src + 1;}}else{printf("从后向前拷贝\n");//从后向前拷贝while (num--){*((char*)dest + num) = *((char*)src + num);}}return ret;
}
memset
memset是一个初始化函数，作用是将某一块内存中的全部设置为指定的值。
- prr 指向要填充的内存块。
- value 是要被设置的值。
- num 是要被设置该值的字符数。
- 返回类型是一个指向存储区s的指针。
使用示例1
int main()
{char arr[] = "hello world";memset(arr + 1, 'x', 4);printf("%s\n", arr);return 0;
}上面代码的作用是将的arr数组的第2个元素到第5个元素的值设置成‘x',输出结果：
使用示例2
int main()
{int arr[10] = { 0 };memset(arr, 1, 10);return 0;
}
memcmp
比较从ptr1和ptr2指针开始的num个字节
返回值如下：
使用示例
int main()
{int arr1[] = { 1,2,1,4,5,6 };int arr2[] = { 1,2,257 };int ret = memcmp(arr1, arr2, 9);printf("%d\n", ret);return 0;
}对于上面的代码，可以借助编译器的调试来查看 arr1 和 arr2 的内存：
可以看出，arr1和arr2的前9个字节是相同的，而我们比较的是前9个字节，因此输出结果应该是0。 
