C语言字符函数、字符串函数、内存函数
strlen函数strlen函数介绍strlen函数的使用模拟实现strlen函数 strcpy函数strcpy函数介绍strcpy函数的使用模拟实现strcpy函数 strcat函数strcat函数介绍strcat函数的使用模拟实现strcat函数 strcmp函数strcmp函数介绍strcmp函数的使用模拟实现strcmp函数 strncpy函数strncpy函数介绍strncpy函数的使用 strncat函数strncat函数介绍strncat函数的使用 strncmp函数strncmp函数介绍strncmp函数的使用 strstr函数strstr函数介绍strstr函数的模拟实现 strtok函数strtok函数介绍 strerror函数strerror函数的介绍 memcpy函数memcpy函数的介绍memcpy函数的使用memcpy函数的模拟实现 memmove函数memmove函数的介绍memmove函数的使用memmove函数的模拟使用 memcmp函数memcmp函数的介绍memcmp函数的使用 memset函数memset函数的介绍memset函数的使用 字符分类和转换函数字符分类函数字符转换函数strlen函数
strlen函数介绍
size_t strlen ( const char * str )
参数：需要一个字符串的地址，const对其进行修饰，使其不能修改
返回值：返回字符串的长度，无符号整型（size_t），所以打印时最好用%ud
注意：1.计算的是字符串的长度，字符串以\0结尾
2.该函数计算的是\0之前的字符数，不包含\0
3.使用所有的字符函数、字符串函数、内存函数都必须包含头文件#include <string.h>
strlen函数的使用
#include <stdio.h>#include <string.h>int main(){char arr0[] = "abcd";//abcd\0char arr1[] = {'a','b','c','d' };//abcd，无法求长度，但可以加'\0'求长度//char arr1[] = { 'a','b','c','d'，'\0'};//正确char arr2[10] = {'a','b','c','d' };//abcd\0\0……，'d'之后都初始化为0，由于是char即'\0'int len0 = strlen(arr0);//4int len1 = strlen(arr1);//随机值int len2 = strlen(arr2);//4printf("%d\n", len0);printf("%d\n", len1);printf("%d\n", len2);if (strlen("abc") > strlen("abcd"))//正确{printf(">\n"); }else{printf("<\n");}if (strlen("abc") - strlen("abcd")>0)//错误，无符号-无符号的结果是无符号{printf(">\n");}else{printf("<\n");}return 0;}
输出结果：
1.字符串的结束标志是’\0’，strlen计算以’\0’作为结束标志，计算之前的字符数，而arr2中不含有’\0’，所以会继续向后找，直到找到’\0’为止，计算结果是个随机值，所以必须保证字符串中有’\0’
2.strlen函数的返回值是无符号整数，所以相减还是无符号整数
模拟实现strlen函数
#include <stdio.h>#include <string.h>#include <assert.h>int MyStrlen(const char* str){int count=0;assert(str != NULL);while (*str){count++;str++;}return count;}int main(){char arr[] = "abcdef";int len = MyStrlen(arr);printf("%d\n", len);//6return 0;}
1.采用计数的形式，利用while循环判断，只要不是’\0’，count会一直加，str不断指向下一个字符的地址
2.assert()是断言函数，当括号中的条件为假（即0）时，会自动打印错误信息，为了避免传过来的是空指针，所以使用assert()函数，assert(str)或assert(str != NULL)
3.利用const来保证str指向的内容不会被修改
采用递归的方式实现
#include <stdio.h>#include <string.h>#include <assert.h>int MyStrlen(const char* str){assert(str != NULL);if (*str!= '\0'){return 1 + MyStrlen(str+1);}elsereturn 0;}int main(){char arr[] = "abcdef";int len = MyStrlen(arr);printf("%d\n", len);//6return 0;}
采用指针 - 指针的方式实现
#include <stdio.h>#include <string.h>#include <assert.h>int MyStrlen(const char* str){const char* start = str;assert(str!= NULL);while (*str){str++;}return str- start;}int main(){char arr[] = "abcdef";int len = MyStrlen(arr);printf("%d\n", len);//6return 0;}
1.两个指针相减代表的是元素的个数
strcpy函数
复制字符串，将source指向的字符串复制到destination所指向的地址中，包括终止空字符
strcpy函数介绍
char * strcpy ( char * destination, const char * source )
参数：从source处指向的地址的内容复制到 destination指向的地址中去
返回值：返回的是目标空间的起始地址
注意：1.源字符串必须以 ‘\0’ 结束
2.会将源字符串中的 ‘\0’ 拷贝到目标空间
3.目标空间必须可变且足够大，以确保能存放源字符串
strcpy函数的使用
#include <stdio.h>#include <string.h>int main(){char arr[] = "******";char arr1[10] = {0 };char arr2[] = "abc";char arr3[] = "123456789";strcpy(arr, arr2);strcpy(arr1, arr3);printf("%s\n", arr);printf("%s\n", arr1);return 0;}
输出结果：
1.从上述图片可以看出把’\0’拷贝了过去
2.利用%s读取第一个’\0’之前的内容
模拟实现strcpy函数
#include <stdio.h>#include <string.h>#include <assert.h>void MyStrcpy(char* dest, const char* src){assert(src != NULL);assert(dest != NULL);while(*src){*dest = *src;dest++;src++;}*dest = *src;}int main(){char arr[] = "******";char arr1[] = "abc";MyStrcpy(arr, arr1);printf("%s\n", arr);return 0;}
代码优化
#include <stdio.h>#include <string.h>#include <assert.h>char* MyStrcpy(char* dest, const char* src){assert(src && dest);char* start = dest;while(*dest++ = *src++){;}return start;}int main(){char arr[] = "******";char arr1[] = "abc";printf("%s\n", MyStrcpy(arr, arr1));return 0;}
输出结果：
1.该函数返回目标空间的起始地址
2.利用断言函数确保dest和src不是空指针
3. while(*dest++ = *src++)，每一次循环先将 *dest = *src，根据 *dest是否为’\0’，来决定循环是否继续，然后src++,dest++，最后当 *dest==‘\0’时，循环中止，此时已经将’\0’拷贝了过去
strcat函数
strcat是字符串追加（连接）函数
strcat函数介绍
char * strcat ( char * destination, const char * source )
参数：destination是指向目标数组的指针，source 要追加的 C 字符串，不应与目标重叠
返回值：返回的是目标空间的起始地址
注意：1.源字符串必须以 ‘\0’ 结束
2.会将源字符串中的 ‘\0’ 拷贝到目标空间
3.目标空间必须可修改且足够大，以确保能存放源字符串
4.从目标字符串中的的’\0’开始追加，并且将目标字符串中的的’\0’覆盖，源字符串中的’\0’也会追加过去
strcat函数的使用
#include <stdio.h>#include <string.h>#include <assert.h>int main(){char arr[10] = "abc";char arr1[] = "def";strcat(arr, arr1);printf("%s\n", arr);//abcdefreturn 0;}
输出结果：
第一种情况是正常追加字符串
第二种是自己给自己追加字符串，发现会陷入死循环，因为自身的’\0’被覆盖了，源字符串无法将’\0’拷贝过去，用来结束拷贝
模拟实现strcat函数
#include <stdio.h>#include <string.h>#include <assert.h>void MyStrcat(char* dest, const char* src){while (*dest){dest++;}while (*src){*dest = *src;src++;dest++;}*dest = *src;}int main(){char arr[10] = "abc";char arr1[] = "def";MyStrcat(arr, arr1);printf("%s\n", arr);//abcdefreturn 0;}
代码优化
#include <stdio.h>#include <string.h>#include <assert.h>char* MyStrcat(char* dest, const char* src){char* p = dest;assert(dest && src);while (*dest){dest++;}while (*dest++ = *src++){;}return p;}int main(){char arr[10] = "abc";char arr1[] = "def";printf("%s\n", MyStrcat(arr,arr1));//abcdefreturn 0;}
1.strcat的拷贝可以与strcpy结合起来，不过要先找到目标地址的’\0’，然后再进行拷贝
strcmp函数
比较两个字符串的大小
strcmp函数介绍
int strcmp ( const char * str1, const char * str2 )
参数：将将 C 字符串 str1 与 C 字符串 str2 进行比较
返回值：str1>str2：返回>0的数值
str1=str2：返回0
str1<str2：返回<0的数值
注意：1.比较的是ASIIC码值，比如"abcd"是小于"ad"的，因为d的阿斯克码值大于b的阿斯克码值
2.此函数是逐个比较每个字符串中的字符，如果相同则继续向下比较，直到不同或到’\0’
strcmp函数的使用
#include <stdio.h>#include <string.h>#include <assert.h>int main(){char arr[] = "abcd";char arr1[] = "af";int ret = strcmp(arr, arr1);if (ret > 0){printf(">\n");}else if (ret < 0){printf("<\n");}else{printf("=\n");}printf("%d\n", ret);return 0;}
输出结果：
1.由于b的ASIIC值小于f的ASIIC值，所以返回小于0的数
模拟实现strcmp函数
#include <stdio.h>#include <string.h>#include <assert.h>int MyStrcmp(const char* str1, const char* str2){assert(str1 && str2);while (*str1 == *str2){if (*str1 == '\0'){return 0;}str1++;str2++;}if (*str1 < *str2){return -1;}elsereturn 1;}int main(){char arr[] = "abc";char arr1[] = "abb";int ret = MyStrcmp(arr, arr1);printf("%d\n", ret);return 0;}
代码优化
#include <stdio.h>#include <string.h>#include <assert.h>int MyStrcmp(const char* str1, const char* str2){assert(str1 && str2);while (*str1 == *str2){if (*str1 == '\0'){return 0;}str1++;str2++;}return *str1 - *str2;}int main(){char arr[] = "abc";char arr1[] = "abb";int ret = MyStrcmp(arr, arr1);printf("%d\n", ret);return 0;}
strncpy函数
从字符串中复制字符
strncpy函数介绍
char * strncpy ( char * destination, const char * source, size_t num )
参数：destination：指向要在其中复制内容的目标数组的指针
source：要复制的 C 字符串
num：从源目标地址要赋值的字节数
返回值：返回目标空间的起始地址
注意：1.num是单位是字节
2.由于str前缀的都是操作字符串，char是一个字节，故num的个数就是几个字符
strncpy函数的使用
#include <stdio.h>#include <string.h>int main(){char arr1[] = "hello world";char arr2[] = "1234";strncpy(arr1, arr2, 4);printf("%s",arr1);return 0;}
输出结果：
1.将arr2的4个字节拷贝过去
2.如果拷贝10个过去，不足的部分会补’\0’
3.将源的第一个字符复制到目标。如果在复制 num 个字符之前找到源 C 字符串（由空字符表示）的末尾，则用零填充目标，直到向其写入了总共 num 个字符
strncat函数
从字符串追加字符
strncat函数介绍
char * strncat ( char * destination, const char * source, size_t num )
参数：destination：指向目标数组的指针，目标数组应包含 C 字符串，并且足够大以包含串联的结果字符串，包括其他空字符
source：要追加的 C 字符串
num：要追加的最大字符数
返回值：返回目标空间的起始地址
注意：1.源的第一个字符追加到目标，以及终止空字符
2.如果源中 C 字符串的长度小于 num，则仅复制终止空字符之前的内容
3.目标空间要大
4.从目标空间’\0’的地方开始追加
strncat函数的使用
#include <stdio.h>#include <string.h>int main(){char arr1[10] = "abc\0def";char arr2[] = "1234";strncat(arr1, arr2, 2);printf("%s",arr1);return 0;}
输出结果：
1.从arr1的’\0’处开始追加
2.会在最后追加’\0’
3.如果arr2中的数目小于要追加的num，最后追加过去只会加一个’\0’
strncmp函数
strncmp函数介绍
int strncmp ( const char * str1, const char * str2, size_t num )
参数：将将 C 字符串 str1 与 C 字符串 str2的num个数 进行比较
返回值：str1>str2：返回>0的数值
str1=str2：返回0
str1<str2：返回<0的数值
注意：1.比较的是ASIIC码值，比如"abcd"是小于"ad"的，因为d的阿斯克码值大于b的阿斯克码值
2.此函数是逐个比较每个字符串中的字符，如果相同则继续向下比较，直到不同或到’\0’
strncmp函数的使用
#include <stdio.h>#include <string.h>int main(){char arr1[] = "abcde";char arr2[] = "abf";int ret = strncmp(arr1, arr2, 3);if (ret > 0){printf(">\n");}else if (ret < 0){printf("<\n");}else{printf("=\n");}return 0;}
输出结果：
1.比较的前3个字符，c<f，所以打印<
strstr函数
strstr函数介绍
char * strstr ( const char *str1, const char * str2)
参数：str1要扫描的字符串，str2要匹配的字符串，总之就是看str1中是否有str2
返回值：返回指向str1中第一次出现str2的指针，如果str2不是str1的一部分，则返回空指针
注意：1.如果str1中找到str2后，返回指向str1中第一次出现str2的指针，此时打印的是str1中与str2相同的内容向后直到str1中的’\0’，停止打印
#include <stdio.h>#include <string.h>#include <assert.h>int main(){char arr[] = "abcdefgbcdh";char arr1[] = "bcd";//在arr中查找是否包含arr2数组//会返回第一次找到的地址char* ret = strstr(arr, arr1);if (ret == NULL){printf("没找到\n");}else{printf("找到了：%s\n", ret);}return 0;}
输出结果：
1.可以看到打印的bcdefgbcdh，有两个bcd，找到第一个后就开始向后打印
strstr函数的模拟实现
#include <stdio.h>#include <string.h>#include <assert.h>char* MyStrstr(const char* str1, const char* str2){assert(str1 && str2);const char* s1 = str1;const char* s2 = str2;const char* ptr = str1;if (*str2 == '\0'){return NULL;}while (*ptr){s1 = ptr;s2 = str2;while (*s1 && *s2 && (*s1 == *s2)){s1++;s2++;}if (*s2 == '\0'){return ptr;}ptr++;}return NULL;}int main(){char arr[] = "bcdddefgbcdh";char arr1[] = "dde";//在arr中查找是否包含arr2数组//会返回第一次找到的地址char* ret = MyStrstr(arr, arr1);if (ret == NULL){printf("没找到\n");}else{printf("找到了：%s\n", ret);}return 0;}
输出结果：
1.将str1和str2分别赋给s1和s2，利用s1和s2的移动来遍历整个字符串
2.ptr用来记录字符相同的位置，起到一个标记作用，找到后作为起始位置返回
3.程序刚运行时，如图所示，*s1和s2不同，while循环不会执行，ptr++指向下一个字符，此时ptr不是’\0’，程序继续执行
3.*s1和s2不同，重复上述动作
4.当ptr++指向第一个d时，此时s1和 *s2相同，且不为’\0’，while循环执行，让s1++,s2++，并且进行比较，直到比到第三个字符d和e不同，循环中止
5.然后让ptr++指向下一个d，此时s1指向的位置是d,s2指向的位置是e，利用s1=ptr，s2=str2，将s1指向第二个d,str2重新开始，然后再进行比较，最后比较成功，返回ptr的地址
6.while (*s1 && *s2 && (*s1 == *s2))，*s1 && *s2是确保两个字符串在’\0’之前进行寻找
strtok函数
切割字符串
strtok函数介绍
char * strtok ( char * str, const char * delimiters )
参数：str要截断的 C 字符串，它包含了0个或者多个由delimiters 字符串中一个或者多个分隔符分割的标记
delimiters 包含分隔符的 C 字符串
返回值：🎈strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
🎈strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
🎈如果字符串中不存在更多的标记，则返回 NULL 指针
注意：1.strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）
#include <stdio.h>#include <string.h>int main(){char* p = "abcdefgh@123456.cpp";const char* sep = ".@";char arr[30];char* str = NULL;strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容str = strtok(arr, sep);printf("%s\n", str);str = strtok(NULL, sep);printf("%s\n", str);str = strtok(NULL, sep);printf("%s\n", str);//for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))//第二种方法//{//printf("%s\n", str);//}}
输出结果：
1.第一次传str的地址，往后传空指针即可，因为strtok此时已经记住了第一次’\0’的位置
strerror函数
strerror函数的介绍
char * strerror ( int errnum )
参数：errnum 错误号
返回值：指向描述错误错误的错误字符串的指针
注意：1.c语言的库函数，在执行失败的时候，都会设置错误码，0、1、2、3、4、5……
2.errno是c语言设置的一个全局的错误码存放的变量
#include <stdio.h>#include <string.h>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));printf("%s\n", strerror(6));printf("--------------------\n");FILE* pf = fopen("add,txt", "r");if (pf == NULL){printf("%s\n", strerror(errno));//两种方式均可打印错误原因perror("错误原因：");}else{}return 0;}
输出结果：
memcpy函数
memcpy函数的介绍
void * memcpy ( void * destination, const void * source, size_t num )
参数：destination指向要在其中复制内容的目标数组的指针，类型转换为 void* 类型的指针
source指向要复制的数据源的指针，类型转换为 const void* 类型的指针
num 要拷贝的字节数
返回值：返回目标空间的起始地址
注意：1.这个函数在遇到 ‘\0’ 的时候并不会停下来，它始终精确地复制数字字节
2.为避免溢出，destination和source所指向的数组的大小应至少为 num 个字节，并且不应重叠，（对于重叠的内存块，memmove 是一种更安全的方法）
memcpy函数的使用
int main(){int arr[10] = {1,2,3,4,5,6};int arr1[10] = {0};int i = 0;memcpy(arr1, arr, 20);for (i = 0; i < 5; i++)printf("%d ", arr1[i]);return 0;}
输出结果：
准确的将前20个字节的内容拷贝了过去
memcpy函数的模拟实现
#include <stdio.h>#include <string.h>#include <assert.h>void* MyMemcpy(void* dest, const void* src, size_t num){void* ret = dest;assert(dest && src);while (num--){*(char*)dest = *(char*)src;dest = (char*)dest + 1;src = (char*)src + 1;}return ret;}int main(){int arr[10] = {1,2,3,4,5,6};int arr1[10] = {0};int i = 0;int* ret=MyMemcpy(arr1, arr, 20);for (i = 0; i < 5; i++)printf("%d ", ret[i]);return 0;}
1.将memcpy函数的形参全部定为为void*，是因为不知道要处理什么数据，利用void接收参数，最后强制类型转换，再解引用即可
2.对dest和src强制类型转换成char的原因是，在内存中字节是最小的单位，对char*进行解引用可以一次访问一个字节，这样无论是什么数据传进来，都可一个字节一个字节的操作
memmove函数
memmove函数的介绍
void * memmove ( void * destination, const void * source, size_t num )
参数：destination：指向要在其中复制内容的目标数组的指针，类型转换为 void* 类型的指针
source：指向要复制的数据源的指针，类型转换为 const void* 类型的指针
num：要复制的字节数内存块的指针
返回值：返回目标空间的起始地址
注意：1.memcpy与memmove的差别就是memmove函数处理的源内存块和目标空间的内存块是可以重叠的
2.当出现重叠时，需要使用memmove
memmove函数的使用
#include <stdio.h>#include <string.h>#include <assert.h>int main(){int arr[10] = {1,2,3,4,5,6,7,8,9,10};memmove(arr + 2, arr, 20);int i = 0;for (i = 0; i < 10; i++)printf("%d ", arr[i]);//12123458910return 0;}
输出结果：
将arr前5个元素即20个字节的内容拷贝到从arr[2]开始向后的5个元素
memmove函数的模拟使用
#include <stdio.h>#include <string.h>#include <assert.h>void* MyMemmove(void* dest, void* src, size_t num){void* ret = dest;assert(dest && src);if (dest < src){while (num--){*(char*)dest = *(char*)src;dest = (char*)dest + 1;src = (char*)src + 1;}}else{while (num--){*((char*)dest + num) = *((char*)src + num);}}return ret;}int main(){int arr[10] = {1,2,3,4,5,6,7,8,9,10};MyMemmove(arr + 2, arr, 20);int i = 0;for (i = 0; i < 10; i++)printf("%d ", arr[i]);//12123458910return 0;}
由于数组不够大，如图所示显示了两种情况，实际有5种
1.dest<src，没有重叠，从src中，前->后 或者 后->前 拷贝都可以
2.dest<src，有重叠部分，从src中，只能由前->后拷贝，反之，前面的数据还没拷贝就被覆盖了
3.dest=src，完全重叠，此时不需要拷贝，直接返回即可
4.dest>src，有重叠部分，从src中，由后->前拷贝
5.dest>src，没有重叠，从src中，前->后 或者 后->前 拷贝都可以
6.总之，当dest<src时，由前->后拷贝
当dest>src时，由后->前拷贝
memcmp函数
memcmp函数的介绍
int memcmp ( const void * ptr1, const void * ptr2, size_t num )
参数：ptr1和ptr2都是指向内存块的指针，num是要比较的字节数
返回值：ptr1>ptr2：返回>0的数值
ptr1=ptr2：返回0
ptr1<ptr2：返回<0的数值
注意：1.将 ptr1 所指向的内存块的前 num 个字节与 ptr2 指向的第一个字节数进行比较，如果它们都匹配，则返回零，或者如果不匹配，则返回与零不同的值，表示哪个值更大
2.与 strcmp 不同，该函数在找到空字符后不会停止比较
memcmp函数的使用
#include <stdio.h>#include <string.h>#include <assert.h>int main(){int arr1[] = {1,2,3,4,5 };int arr2[] = {1,2,4,1 };int ret = memcmp(arr1, arr2, 12);printf("%d",ret);}
输出结果：
1.该结果说明arr1的前12个字节大小小于第二块内存的前12个字节大小
2.一次比较一个字节
3.很明显橘色框中的数据arr1小于arr2,所以返回-1
memset函数
memset函数的介绍
void * memset ( void * ptr, int value, size_t num )
参数：ptr：指向要填充的内存块的指针
value：要设置的值，也可以是字符
num：要设置的字节数
返回值：若成功开辟内存空间，返回指向函数分配的内存块的指针，若开辟失败，则返回一个空指针NULL，故需要对返回值进行检查
注意：1.该函数是以字节为单位进行初始化的
memset函数的使用
#include <stdio.h>#include <string.h>#include <assert.h>int main(){char arr1[] = "hello world";int arr2[10] = {0 };memset(arr1,'6', 5);memset(arr2, 1, 40);printf("%s\n",arr1);int i = 0;for (i = 0; i < 10; i++){printf("%d\n", arr2[i]);}}
输出结果：
1.没有输出1的原因是，memset操作的是1个字节，即01 01 01……，所以不会打印1
字符分类和转换函数
字符分类函数
字符转换函数
int tolower(int c)//转小写int toupper(int c)//转大写
#include <stdio.h>#include <string.h>#include <ctype.h>int main(){int a = isdigit(0);printf("%d\n", a);a = isdigit('0');printf("%d\n", a);a = isspace(' ');printf("%d\n", a);printf("--------------------\n");printf("%c\n", tolower('A'));printf("%c\n", tolower('!'));//不变printf("%c\n", toupper('a'));return 0;}
输出结果：
