---

---

前言

---

一、字符串函数

1.求字符串长度

strlen

1、功能：求字符串长度
2、使用：
（1）介绍：

说明：
a.返回类型是size_t，也就是无符号整形（只有正数没有负数）
b.参数是char* 类型；加入const修饰是为了防止对str中存放的内容进行修改
c.字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )

（2）头文件：<string.h>
（3）举例：
  a.

int main() {char arr1[] = "abcdefg";size_t len1 = strlen(arr1);return 0;
}

解析：
(1)strlen函数做需要的参数是char* 类型，所以创建了一个char类型的数组
(2在不是sizeof(数组名)与 &数组名 的情况下，数组名代表数组首元素的地址，首元素地址的类型是char*
(3)strlen 函数的返回值是size_t类型，也就是无符号的整形，所以我们设置一个相应类型的值来接收它

 b.

int main() {char* arr2 = "abcdef";size_t len2 = strlen(arr2);size_t len3 = strlen("abcdef");printf("%d %d\n",len2,len3);return 0;
}

结果：

解析：
这里的len2和len3的最后结果其实是一致的，因为len3中的字符串其实传输的也是首元素的地址，属于char*类型，与len2中的传输的值是一样的
 c.

int main() {char* arr3 = "abc\0def";char* arr4 = "abcde\0f";size_t len3 = strlen(arr3);size_t len4 = strlen(arr4);printf("%d %d\n", len3, len4);return 0;
}

结果：
解析：
strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )

（4）注意事项：
 a.参数指向的字符串必须要以 ‘\0’ 结束。
 b.注意函数的返回值为size_t，是无符号的

3、模拟实现：
 方法一：

size_t my_strlen(const char* str) {//计录字符串长度size_t count = 0;//当*str='\0'是停止while (*str) {count++;str++;}return count;
}int main() {char arr1[] = "abcdefg";size_t len1 = my_strlen(arr1);printf("%d\n",len1);return 0;
}

#emsp;方法二

//递归实现
size_t my_strlen(const char* str) {if (*str == '\0') {return 0;}//这里不能使用后置++，因为它是先使用后++return 1 + my_strlen(str+1);
}int main() {char arr1[] = "abcdefg";size_t len1 = my_strlen(arr1);printf("%d\n", len1);return 0;
}

 方法三：

//指针实现
size_t my_strlen(const char* str) {//创建一个临时变量来接收strchar* p = str;//对临时变量进行操作更加安全while (*p != '\0') {p++;}//字符串中有几个字符，p就会往后移动几位return p - str;
}int main() {char arr1[] = "abcdefg";size_t len1 = my_strlen(arr1);printf("%d\n", len1);return 0;
}

2.长度不受限制的字符串函数

(1)strcpy

1、功能：字符串拷贝
2、使用：
（1）介绍：

说明：
a.参数有两个，都是char* 类型：拷贝源与目的地
b.返回值是char* 类型，返回目的地的地址
c.头文件：<string.h>

(2)注意：
a.源字符串必须以 ‘\0’ 结束,，因为它是拷贝结束的标志，没有的话会一直拷贝，会越界访问
b.会将源字符串中的 ‘\0’ 拷贝到目标空间。
c.目标空间必须足够大，以确保能存放源字符串。
d.目标空间必须可变。

（3）举例：
a.

int main() {char arr1[20];char arr2[] = "abcdef";printf("%s\n",arr1);strcpy(arr1,arr2);printf("%s\n",arr1);return 0;
}

结果：
解析：
未对arr1进行初始化化，所以刚开始赋予的是随机值；在strcpy函数后，为其拷贝了值

3、模拟实现

char* my_strcpy(char* dest,const char* src) {//设置一个指针来存储目的地的起始地址char* ret = dest;//设置断言，防止对空指针解引用assert(src && dest);//对dst赋值，当赋值'\0'后不满足条件，退出循环while (*dest++ = *src++) {;}return ret;
}int main() {char arr1[20];char arr2[] = "abcdef";my_strcpy(arr1,arr2);printf("%s\n",arr1);return 0;
}

(2)strcat

1、功能：字符串追加
2、使用：
（1）介绍：

说明：
a.参数有两个，char*类型：源和目的地
b.返回的是目的地的起始地址
c.本函数是寻找目的地中的’\0’，从’\0’处开始追加源中的字符，并将原来的’\0’替换，将自己的’\0’拷贝过去

（2）注意：
a.必须保证目标空间要足够大
b.目标空间中必须有\0（保证能找到目标空间的末尾）
c.原字符串也得有\0，在拷贝时将\0也拷过去
d.目标空间必须可以修改

（3）举例：

int main() {char arr1[20] = "abcd";char arr2[] = "efgh";strcat(arr1,arr2);printf("%s\n",arr1);return 0;
}

结果：

3、模拟实现

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

(3)strcmp

1、功能：字符串比较
2、使用：
（1）介绍：


说明：
a.参数有两个，是比较的两个数组
b.当字符串1>字符串2时，返回一个>0的数
 当字符串1=字符串2，返回一个<0的数
 当字符串1<字符串2时，返回一个<0的数
c.两字符串比较的其实是每个字符的ASCII码值

(2)注意：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

（3）举例：

int main() {char arr1[] = "abbc";char arr2[] = "abcd";int ret = strcmp(arr1,arr2);printf("%d\n",ret);return 0;
}

3、模拟实现

int my_strcmp(const char* arr1,const char* arr2) {assert(arr1 && arr2);while (*arr1 == *arr2) {arr1++;arr2++;if (*arr1 == '\0') {return 0;}}if (*arr1 > *arr2)return 1;if (*arr1 < *arr2)return -1;
}int main() {char arr1[] = "abbc";char arr2[] = "abcd";int ret = my_strcmp(arr1,arr2);printf("%d\n",ret);return 0;
}

3.长度受限制的字符串函数

(1)strncpy

1、功能：限制数量的字符串拷贝
2、使用：
（1）介绍：

说明：多了一个数量限制，其余的与函数strcpy一致
（2）注意：
a.当源字符串中的字符数没有达到参数的数量时，会在目的地中自动补’\0’，直到达到限定数量
b.目的地的大小应该比限定数量大，否则就会非法访问
（3）举例：
a.

int main() {char arr1[10];char arr2[] = "abcdefg";strncpy(arr1,arr2,10);printf("%s\n",arr1);return 0;
}

结果：

(2)strncat

1、功能：限制数量的字符串追加
2、使用：
（1）介绍：

说明：多了一个数量限制，其余与函数strcat一致
（2）注意：
与函数strcat一致
（3）举例：
a.

int main() {char arr1[20] = "bcc";char arr2[] = "abcdefg";strncat(arr1, arr2, 10);printf("%s\n", arr1);return 0;
}

结果：

(3)strncmp

1、功能：限制数量的字符串比较
2、使用：
（1）介绍：

（3）举例：
a.

int main() {char arr1[] = "abc";char arr2[] = "abcdefg";int ret = strncmp(arr1, arr2, 4);printf("%d\n", ret);return 0;
}

结果：

4.字符串查找

(1)strstr

1、功能：字符串查找
2、使用：
（1）介绍：

说明：
a.有两个参数都是char类型，在str1中查找是否有str2中的字符串
b.返回值是char 类型，返回的是str1中查找的字符串的首地址
（2）注意：
a.如果字符串中有两个查找的字符串，会默认返回第一个找到的字符串的首地址
b.查找不到时会返回Null值
c.查找过程中碰到’\0’就会停止

（3）举例：
a.

int main() {char arr1[] = "abccbcccf";char arr2[] = "bccc";char * ret = strstr(arr1, arr2);printf("%s\n", ret);return 0;
}

结果：
b.

int main() {char arr1[] = "abccbcccf";char arr2[] = "g";char * ret = strstr(arr1, arr2);printf("%s\n", ret);return 0;
}

结果：

c.

int main() {char arr1[] = "abc\0bcccf";char arr2[] = "bccc";char * ret = strstr(arr1, arr2);printf("%s\n", ret);return 0;
}

结果：

3、模拟实现

const char* my_strstr(const char* str1,const char* str2) {//创建一个临时变量作为查找元素时的定位符const char* p = str1;const char* s1;const char* s2;assert(str1 && str2);while (*p) {//每次都从p处开始比较s1 = p;//如果没有完全找到，就要重头开始找s2 = str2;//不相等或者任意一方为'\0'时停止while ((*s1 && *s2 && *s1 == *s2)) {s1++;s2++;}//判断是否全部找到if (*s2 == '\0') {return p;}p++;}return NULL;
}int main() {char arr1[] = "abccbcccf";char arr2[] = "bc";char * ret = my_strstr(arr1, arr2);printf("%s\n", ret);return 0;
}

(2)strtok

1、功能：字符串分隔
2、使用：
（1）介绍：

说明：
a.有两个参数，都是char类型，第一个是等待分割的字符串，第二个是分隔符
b.返回值是charl类型，返回分隔后的字符串的首地址

（2）注意：
a.每次调用只会对字符串进行一次分隔
b.函数strtok会记住上一次分隔的结束位置，从那个位置开始进行下一次分割，但此次不能为它传输新的字符串指针，只能传输分隔符

（3）举例：
a.

int main() {char arr1[] = "abc@de.fg@h";char* d = "@.";char* ret = strtok(arr1, d);printf("%s\n", ret);return 0;
}

结果：

b.

int main() {char arr1[] = "abc@de.fg@h";char* d = "@.";for (char* ret = strtok(arr1, d); ret != NULL; ret = strtok(NULL, d)) {printf("%s\n",ret);}return 0;
}

结果:

5.错误信息报告

(1)strerror

1、功能：错误信息反馈
2、使用：
（1）介绍：

a.头文件<errno.h>
b.参数是int类型，是错误所对应的错误码
c.返回值是char* 类型，返回错误码，所对应的错误信息

（2）注意：
a.当程序产生错误时，会自动将错误码放入错误信息errno中
（3）例子：
a.

int main() {for (int i = 0; i <= 10; i++) {printf("%d %s\n",i,strerror(i));}return 0;
}

结果：

b.

//打开文件
int main() {//打开成功返回一个FILE* 类型的指针，打开失败返回一个NULL指针FILE* pfile = fopen("add.txt","r");//产生错误的时候，会自动的将错误码放入错误信息errno中if (pfile == NULL) {printf("打开失败的原因是:%s\n",strerror(errno));}return 0;
}

结果：

(2)perror

1、功能：错误信息打印
2、使用：
（1）介绍：

说明：此处参数可传可不传，属于你的自定义信息，类似与printf中你输入的文字，它会默认将程序中的错误信息打印出来，你可以自由加一些自定义信息

(2)注意：
a.打印规则，先打印自定义信息，然后 “ ：空格”，再打印错误信息

（3）实例：

int main() {FILE* pfile = fopen("add.txt", "r");if (pfile == NULL) {perror("打开失败的原因是");}return 0;
}

结果：

二、内存函数

内存函数与字符串函数最重要的区别是：内存函数适用于所有类型

1.memcpy

1、功能：内存拷贝
2、使用：
（1）介绍：

说明：
a.头文件：<string.h>
b.参数有三个，前两个是void* 类型的，是拷贝源于目的地；最后一个是拷贝的字节数

（2）注意：
a.传输的数字是字节数，而不是元素个数
b.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
c.这个函数在遇到 ‘\0’ 的时候并不会停下来。
d.如果source和destination有任何的重叠，复制的结果都是未定义的。
（3）示例：
a.

int main() {int arr1[10] = {0};int arr2[] = { 1,2,3,4,5 };memcpy(arr1,arr2,20);return 0;
}

结果：

3、模拟实现

void* my_memcpy(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 arr1[10] = { 0 };int arr2[] = { 1,2,3,4,5 };my_memcpy(arr1,arr2,20);return 0;
}

2.memmove

1、功能：内存移动
2、使用：
（1）介绍：

说明：
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。
（2）注意：
a.在模拟实现中，起码要有两种情况

（3）示例：
a.

int main() {char arr1[] = "abcdefgh";memmove(arr1+2,arr1+3,4);printf("%s\n",arr1);return 0;
}

结果：

3、模拟实现：

void* my_memmove(void* dest,const void* src,size_t num) {void* ret = dest;assert(dest && src);//小于时，从后往前拷贝if (src < dest) {while (num--) {*((char*)dest+ num) = *((char*)src+num);}}//其他情况，从前往后拷贝else{while (num--) {*(char*)dest = *(char*)src;src = (char*)src + 1;dest = (char*)dest + 1;}}return ret;
}

3.memset

1、功能：内存设置
2、使用：
（1）介绍：

说明：以字节为单位设置值
（2）注意：
a.因为单位是字节，所以最适用于字符类型的数组

（3）示例：
a.
int main() {
char arr1[] = “hello world”;
memset(arr1+6, ‘a’, 5);
printf(“%s\n”,arr1);
}
结果：

4.memcmp

1、功能：内存比较
2、使用：
（1）介绍：

说明：比较两内存空间的前num个字节的内容

（2）注意：
第一个内存块大于第二个内存块，则返回大于0的数字
第一个内存块等于第二个内存块，则返回0
第一个内存块小于第二个内存块，则返回小于0的数字

（3）示例：
a.

int main() {int arr1[] = { 1,2,3,4,5 };int arr2[] = { 1,3,3,4,5 };int ret1 = memcmp(arr1,arr2,4);//小端存储int ret2 = memcmp(arr1,arr2,5);printf("%d %d\n",ret1,ret2);
}

结果：