【C语言进阶】 一篇带你掌握字符串和内存函数

目录

• 一：strlen
• • 模拟实现：
• 二：strcpy
• • 模拟实现：
• 三：strcat
• • 模拟实现：
• 四：strcmp
• • 模拟实现：
• 五：strncpy
• • 模拟实现：
• 六：strncat
• • 模拟实现：
• 七：strncmp
• • 模拟实现：
• 八：strstr
• • 模拟实现：
• 九：strtok
• • 代码实现：
• 九：strerror
• 十：perror
• 十一：一些字符函数
• • 字符分类函数：
  • 字符转换函数：
• 十二：memcpy
• • 模拟实现：
• 十三：memmove
• • 模拟实现：
• 十四：memcmp
• 十四：memset

一：strlen

strlen：计算字符串长度函数
size_t strlen ( const char * str );

注意事项：

• 字符串以'\0'作为结束标志，strlen函数返回值是在字符串中'\0'前面出现的字符个数（不包含'\0'）
• 参数是一个字符指针变量
• 参数指向的字符串必须要以'\0'结束，否则计算出的长度是随机值
• 注意函数的返回值为size_t，是无符号的

 因为返回值是size_t，所以就要避免出现下面这样的代码：strlen("abc") - strlen("abcde")，strlen("abc")算出的结果是3， strlen("abcde")算出的结果是5，可能想着3-5得到-2，实际上并不是这样的，这里算出的3和5都是无符号整型，算出的-2也是一个无符号整型，-2在内存中以补码的形式存储，从无符号整型的视角看去，这串补码就表示一个很大的正数。

模拟实现：

//常规实现int my_strlen1(const char* arr){assert(arr != NULL);int count = 0;while (*arr){count++;arr++;}return count;}//递归实现int my_strlen2(const char* arr){assert(arr!=NULL);if (*arr == '\0'){return 0;}else{return 1 + my_strlen2(arr + 1);}}//指针减指针实现int my_strlen3(const char* arr){assert(arr != NULL);const char* start = arr;while (*arr){arr++;}return arr - start;}int main(){char arr[] = "abcdef";int len = my_strlen3(arr);printf("%d\n", len);return 0;}

二：strcpy

strcpy：字符串拷贝函数，把源字符串拷贝到目标空间
char * strcpy ( char * destination, const char * source );

注意事项：

• 函数有两个参数，其中source指向待拷贝的字符串，也叫做源字符串，destination是目标空间的地址
• 源字符串必须以’\0’结束
• 会把源字符串中的 ‘\0’ 也拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串，否则会出现非法访问
• 目标空间必须可变，例如把源字符串拷贝到一个字符串常量里面是不可取的

模拟实现：

char* my_strcpy(char* dest, const char* src){assert(dest && src);char* ret = dest;while (*dest++ = *src++){;}return ret;}int main(){char arr1[20] = { 0 };char arr2[] = "hello world";my_strcpy(arr1, arr2);printf("%s\n", arr1);return 0;}

三：strcat

strcat：字符串追加函数，将源字符串追加到目标字符串后面，目标中的终止字符’\0’会被源字符串的第一个字符覆盖
char * strcat ( char * destination, const char * source );

注意事项：

• 函数有两个参数，其中source指向要追加的字符串，也叫做源字符串，destination是目标空间的地址
• 目标空间中必须要有'\0'，作为追加的起始地址
• 源字符串中也必须要有'\0'作为追加的结束标志
• 目标空间必须足够大，能容纳下源字符串的内容
• 目标空间必须可修改
• 自己给自己追加会陷入死循环

模拟实现：

char* my_strcat(char* dest, const char* src){assert(dest && src);char* ret = dest;//找目标空间的'\0'while (*dest != '\0'){dest++;}//追加while (*dest++ = *src++){;}return ret;}int main(){char arr1[20] = "hello ";char arr2[] = "world";my_strcat(arr1, arr2);printf("%s\n", arr1);return 0;}

四：strcmp

strcmp：字符串比较函数
int strcmp ( const char * str1, const char * str2 );

注意事项：

• 这里比较的不是两个字符串的长度，而是对应位置上的ASCII值
• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现：

int my_strcmp(const char* str1, const char* str2){assert(str1 && str2);while (*str1 == *str2)//如果相等就进去，两个指针加加，但是可能会出现两个字符串相等的情况，两个指针都指向'\0'，此时比较就结束了{if (*str1 == '\0'){return 0;}str1++;str2++;}if (*str1 > *str2){return 1;}else{return -1;}}int main(){char arr1[] = "abq";char arr2[] = "abq";int ret=my_strcmp(arr1, arr2);printf("%d\n", ret);return 0;}

五：strncpy

strncpy：长度受限的字符串拷贝函数
char * strncpy ( char * destination, const char * source, size_t num );

注意事项：

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

模拟实现：

char* my_strncpy(char* dest, const char* src, int num){assert(dest && src);char* ret = dest;while (num){if (*src == '\0')//此时说明src指针已经指向了待拷贝字符串的结束标志'\0'处，src指针就不用再++了{*dest = '\0';dest++;}else{*dest = *src;dest++;src++;}num--;}return ret;}int main(){char arr1[20] = "xxxxxxxxxxxxxxxxxxx";my_strncpy(arr1, "abcdef", 10);printf("%s\n", arr1);return 0;}

六：strncat

strncat：长度受限的字符串追加函数
char * strncat ( char * destination, const char * source, size_t num );

注意事项：

• 从源字符串的第一个字符开始往后数num个字符追加到目标空间的后面，外加一个终止字符。
• 如果源字符串的长度小于 num，则仅复制终止字符之前的内容。

模拟实现：

char* my_strncat(char* dest, const char* src, int sz){assert(dest && src);char* ret = dest;//找目标空间的\0while (*dest != '\0'){dest++;}//追加while (sz){*dest++ = *src++;sz--;}*dest = '\0';return ret;}int main(){char arr1[20] = "abc\0xxxxxxxxxxx";my_strncat(arr1, "defjhigk", 3);printf("%s\n", arr1);return 0;}

七：strncmp

strncmp：长的受限的字符串比较函数
int strncmp ( const char * str1, const char * str2, size_t num );

注意事项：

• 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

模拟实现：

int my_strncmp(const char* str1, const char* str2, int sz){assert(str1 && str2);while (sz){if (*str1 < *str2){return -1;}else if (*str1 > *str2){return 1;}else if(*str1 == '\0'||*str2 =='\0')//当有一个为'\0'，说明比较就可以结束了{if (*str1 == '\0' && *str2 == '\0')//如果二者都是'\0'，说明两个字符串相等{return 0;}else if(*str1 =='\0')//如果str1为'\0'，说明str1小，str2大{return -1;}else//如果src为'\0'，说明str1大，str2小{return 1;}}sz--;str1++;str2++;}}int main(){int ret = my_strncmp("abcdef", "abcd", 5);printf("%d\n", ret);return 0;}

八：strstr

strstr：字符串查找函数
const char * strstr ( const char * str1, const char * str2 );

注意事项：

• 在str1指向的字符串中查找str2指向的字符串
• 返回一个指向str1中第一次出现的str2的指针
• 如果 str2 不是 str1 的一部分，则返回一个空指针
• 匹配过程不包括终止空字符，但它到此为止

模拟实现：

char* my_strstr(char* str1, char* str2){assert(str1 && str2);if (*str2 == '\0'){return str1;}char* s1 = str1;char* s2 = str2;char* cp = str1;while (*cp){s1 = cp;s2 = str2;while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2){s1++;s2++;}if (*s2 == '\0'){return cp;}cp++;}return NULL;}int main(){char arr1[] = "abbvcbcbbdbbvbnui";char arr2[] = "bbvb";char* ret = my_strstr(arr1, arr2);if (ret == NULL){printf("找不到\n");}else{printf("%s\n", ret);}return 0;}

九：strtok

strtok：字符串拆分函数
char * strtok ( char * str, const char * sep );

注意事项：

• sep参数是个字符串，定义了用作分隔符的字符集合
• 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记
• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
• strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
• strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
• 如果字符串中不存在更多的标记，则返回 NULL 指针

代码实现：

int main(){char arr[] = "konglong@qq.com";char* p = "@.";char buf[20] = { 0 };strcpy(buf, arr);char* ret=NULL;for (ret = strtok(buf, p); ret != NULL; ret = strtok(NULL, p)){printf("%s\n", ret);}return 0;}

九：strerror

strerror：把错误码转换成错误信息的函数
char * strerror ( int errnum );

注意事项：

• C语言的库函数在运行的时候，如果发生错误，就会把错误码存在一个变量中，这个变量是：errno
• 返回的指针指向静态分配的字符串（错误信息字符串）

一些错误码对应的错误信息：

int main(){printf("%s\n", strerror(0));printf("%s\n", strerror(1));printf("%s\n", strerror(2));printf("%s\n", strerror(3));printf("%s\n", strerror(4));printf("%s\n", strerror(5));return 0;}//结果：No errorOperation not permittedNo such file or directoryNo such processInterrupted function callInput/output error

strerror函数的一般用法：

int main(){//打开文件FILE* pf = fopen("test.c", "r");if (pf == NULL){printf("%s\n", strerror(errno));//需要包含头文件#includereturn 1;}//读文件//关闭文件fclose(pf);return 0;}//打开失败时屏幕显示：No such file or directory

 fopen是一个打开文件的函数，第一参数是文件名，第二个参数是打开方式，如果打开成功会返回一个有限的指针，打开失败会返回一个空指针，此时我们就可以通过strerror函数去查看为什么打开失败

十：perror

perror：直接打印错误信息的函数
void perror ( const char * str );

注意事项：

• str指向一个字符串，这个字符串包含要在错误消息本身之前打印的自定义消息。如果是空指针，则不会打印前面的自定义消息，但仍会打印错误消息
• 如果参数 str 不是空指针，则打印 str 后跟冒号 （:)和一个空间。然后，无论 str 是否为空指针，都会打印生成的错误描述，后跟换行符 （'\n'）

perror函数的一般用法：

int main(){//打开文件FILE* pf = fopen("test.txt", "r");if (pf == NULL){perror("fopen");return 1;}//读文件//关闭文件fclose(pf);return 0;}//打开失败时显示：fopen: No such file or directory

十一：一些字符函数

字符分类函数：

字符转换函数：

tolower：将大写字母转换为小写字母
int tolower ( int c );

注意事项：

• 如果 c 是大写字母并且具有小写等效字母，则将 c 转换为其小写等效项。如果无法进行此类转换，则返回的值为 c 不变。
• 大写字母是以下任意字母：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z，分别翻译为：a b c d e f g h i j k l m n o p q r s t u v w x y z
• 这里是值传递，不会改变实参

toupper：将小写字母转换成大写字母
int toupper ( int c );

注意事项：

• 如果 c 是小写字母并且具有大写等效字母，则将 c 转换为其大写等效字母。如果无法进行此类转换，则返回的值为 c 不变
• 这里是值传递，不会改变实参

应用：

int main(){char arr[] = "I Have An Apple";int i = 0;while (arr[i]){if (isupper(arr[i])){printf("%c", tolower(arr[i]));//把转换的小写字母直接打印出来}else{printf("%c", arr[i]);}i++;}return 0;}//结果：i have an appleint main(){char arr[] = "I Have An Apple";int i = 0;while (arr[i]){if (isupper(arr[i])){arr[i] = tolower(arr[i]);//用转换后的小写字符替换原有的大写字符}printf("%c", arr[i]);i++;}return 0;}

 以上介绍的这些函数都是针对字符串或者字符的，那如果我们要拷贝其他类型的数据呢？用上面这些函数自然就行不通了，此时就要用到即将介绍的内存函数了。

十二：memcpy

memcpy：内存拷贝函数
void * memcpy ( void * destination, const void * source, size_t num );

注意事项：
这里的destination指向要在其中赋值内容的目标数组，source指向要复制的数据源，num是要复制的字节数，注意这里前两个指针的的类型还有函数返回值都是void*，这是因为，memcpy这个函数是内存拷贝函数，它有可能拷贝整型，浮点型，结构体等等各种类型的数据……虽然返回类型是void*，但他也是必不可少的，void*也表示一个地址，用户可以把它强制转换成自己需要的类型去使用。

应用：

//把arr1中的1、2、3、4、5拷贝到arr2数组中int main(){int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0 };memcpy(arr2, arr1, 20);//拷贝5个整型，就是20个字节return 0;}//把arr1中的3、4、5、6拷贝到arr2数组中int main(){int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0 };memcpy(arr2, arr1+2, 16);//此时只要改变参数中数据源的地址就可以，把3的地址传过去就行，复制4个整型就是1个字节return 0;}

模拟实现：

void* my_memcpy(void* dest, const void* src, size_t num){assert(dest && src);void* ret = dest;while (num){*(char*)dest = *(char*)src;((char*)dest)++;((char*)src)++;num--;}return ret;}int main(){int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0 };my_memcpy(arr2, arr1+2, 16);return 0;}

 上面代码中模拟出来的my_memcpy函数已经可以实现把arr1数组中的元素拷贝到arr2数组里面去。但当我们想把arr1数组中的1、2、3、4、5拷贝到arr1数组中的3、4、5、6、7上去时，就会发生错误，如下图：

原因是：当1拷贝到3上时，原来的3已经被1替换，当2拷贝到4上的时候，原来的4已将被2替换。所以当拷贝arr[2]到arr[4]上的时候，原本arr[2]里面存放的3已将被1替换了，同理，所以才得出了不符合我们预期的结果。那如何解决这个问题呢？先来分析这个问题产生的原因，这是因为源空间与目标空间之间有重叠，这里的arr[2]、arr[3]、arr[4]既是源空间也是目标空间，当拷贝1和2的时候把源空间中开没有拷贝的3和4就给覆盖了，此时源空间arr[2]和arr[3]里面存的就不再是3和4了，而是1和2，所以此时拷贝arr[2]和arr[3]里面的数据，其实拷贝的就是1和2。为了解决这个问题，我们可以从后往前拷贝，此时就不会出现这样的问题

解决的思路就是：先拷贝重叠区域的元素，避免其还没拷贝就被覆盖掉。但并不是一遇到源空间和目标空间重叠就从后王前拷贝，比如下面这样，此时要把3、4、5、6、7拷贝到1、2、3、4、5里面

此时就不能用上面的方法从后往前拷贝了，但是可以根据上面提到的解决思路：先拷贝重叠区域的元素，所以此时就应该从前往后拷贝，即按照3、4、5、6、7的顺序去拷贝
因此在拷贝的时候，是按照从前往后的顺序还是从后往前的顺序得看具体的情况。当目标空间的起始位置在源空间的前面时，就得从前往后进行拷贝。当目标空间的起始位置在源空间的后面的时候，就要从后往前拷贝。当源空间和目标空间没有任何重叠的时候，不管是从前往后拷贝还是从后往前拷贝效果都一样。
接下来介绍的memmove函数就可以完成重叠空间的元素拷贝。

十三：memmove

memmove：内存拷贝函数
void * memmove ( void * destination, const void * source, size_t num );
它的参数、返回值与memcpy函数一模一样。这里就不过多介绍。对于这两个函数来说，目标空间必须足够大，不然就会发生越界访问。

模拟实现：

void* my_memmove(void* dest, const void* src, int 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{//从后往前while (num--)//num为1的时候，下面的num就是0{*((char*)dest + num) = *((char*)src + num);//通过num的减减就可以实现对每一个字节的访问}}return ret;}int main(){int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };my_memmove(arr1+2, arr1, 20);return 0;}

十四：memcmp

memcmp：内存比较函数
int memcmp ( const void * ptr1, const void * ptr2, size_t num );

注意事项：

• 比较从ptr1和ptr2指针开始的num个字节
• 两个内存块中不匹配的第一个字节在 ptr1 中的值低于 ptr2 中的值返回一个小于零的数子，相等返回零，两个内存块中不匹配的第一个字节在 ptr1 中的值大于在 ptr2 中的值返回一个大于零的数子

应用

int main(){int arr1[] = { 1,2,6 };//01 00 00 00 02 00 00 00 06 00 00 00int arr2[] = { 1,2,5 };//01 00 00 00 02 00 00 00 05 00 00 00int ret = memcmp(arr1, arr2, 9);printf("%d\n", ret);return 0;}//结果：1

十四：memset

memset：内存设置函数
void * memset ( void * ptr, int value, size_t num );

注意事项：

• 以字节为单位来设置内存中的数据，把从ptr开始往后的num个字节设置成value
• 形参value也可以是字符，字符其实也是整型，因为字符在内存中存的是其ASCII
• value如果是整数的话，需要注意它的取值范围，因为一个字节最大可以存储255，超过255就会发生截断

应用：

int main(){char arr[] = "hello word";memset(arr, 'x', 5);//先把"hello"改成"xxxxx"printf("%s\n", arr);memset(arr + 6, 'y', 4);//再把"word"改成"yyyy"printf("%s\n", arr);return 0;}//