c_character_string 字符串----我认真的弄明白了，也希望你们也是。

字符串

1. 字符串长度strlen

1.1strlen 函数介绍

size_t strlen ( const char * str );

strlen ——string length
strlen 的头文件是 #include <string.h>
参数指向的字符串必须要以 ‘\0’ 结束。
strlen 是求字符串长度的函数，统计的是字符串中\0之前出现的字符个数（不包含 ‘\0’ )。
注意函数的返回值为size_t，是无符号的。

示例1：

#include <stdio.h>
#include <string.h>
int main()
{char arr1[] = "abcdef";char arr2[] = { 'a','b','c','d','e','f' };char arr3[9] = { 'a','b','c','d','e','f' };printf("%d\n", strlen(arr1));printf("%d\n", strlen(arr2));printf("%d\n", strlen(arr3));return 0;
}打印：
6
12
6
arr1 是字符串，字符串的结束标志是 \0,所以 strlen 计算的是 \0之前出现的字符个数,所以是6。
arr2 是字符，arr2 里面没有 \0, 所以 strlen 计算的时候会一直往下计算直到遇到 \0 才会停下，是个随机值。
arr3 是字符串数组,数组数量为6个,所以才会打印6。

示例2：

#include <stdio.h>
#include <string.h>
int main()
{char arr1[] = "abc";char arr2[] = "abcdef";if (strlen(arr1) - strlen(arr2) > 0)printf(">\n");elseprintf("<\n");return 0;
}
运行结果：
大于strlen 计算出 arr1 的值是3，arr2 的值是6，arr1 - arr2 = -3 <0; 怎么会打印 > 呢？
因为函数的返回值为size_t，是无符号的。arr1 和 arr2 的返回值是无符号的，两个无符号的值相减的结果也是无符号的，即使结果是-3 也会被当成无符号数处理，一定会大于0，打印的结果就是 > 。

1.2 strlen 函数的模拟实现

方法一：计数器方式

#include <stdio.h>
#include <string.h>
size_t my_strlen(const char* str)
{int count = 0;while (*str){count++;str++;}return count;
}
int main()
{char arr[] = "abcdef";int len = my_strlen(arr);printf("%d\n", len);return 0;
}

方法二：指针-指针的方式

#include <stdio.h>
#include <string.h>
#include <assert.h>
size_t my_strlen(const char* str)
{assert(str);//确保str不为空指针const char* start = str;const char* end = str;while (*end != '\0'){end++;}return end - start;
}
int main()
{char arr[] = "abcdef";int len = my_strlen(arr);printf("%d\n", len);return 0;
}

方法三：不能创建临时变量计数器（递归求解）

#include <stdio.h>
#include <string.h>
size_t my_strlen(const char* str)
{if (*str == '\0')return 0;elsereturn 1 + my_strlen(str + 1);
}
int main()
{char arr[] = "abcdef";int len = my_strlen(arr);printf("%d\n", len);return 0;
}

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

长度不受限制的字符串和字符串长度没有关系，只关心\0

2.1 strcpy

2.1.1 strcpy 函数介绍

char *strcpy(char *dest, const char *src);

strcpy 的头文件是 #include <string.h>
源字符串必须以 ‘\0’ 结束。
strcpy 会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。注意：常量字符串不可以修改不可以放到目标空间里。

示例：

#include <stdio.h>
#include <string.h>
int main()
{char arr1[20] = { 0 };char arr2[] = "hello";strcpy(arr1, arr2);printf("%s\n", arr1);printf("%d\n", strlen(arr1));printf("%d\n",  strlen(arr2));return 0;
}运行结果:
hello
5
5  //strcpy 会将源字符串中的 ‘\0’ 拷贝到目标空间。

2.1.2 strcpy 函数模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* str)//str加const确保str不被修改
{assert(dest);assert(str);char* ret = dest;while (*dest++ = *str++){;}return ret;
}
int main()
{char arr1[20] = "abc";char arr2[] = "hello word";printf("%s\n", my_strcpy(arr1, arr2));return 0;
}运行结果：hello word

2.2 strcat

2.2.1 strcat 函数介绍

char *strcat(char *dest, const char *src)

strcat 字符串追加函数，头文件是 #include <string.h>，把源字符串追加到目标字符串，在目标字符串的\0后处开始追加，遇到源字符串的\0停止追加。追加的时候会把源字符串的\0一起追加到目标字符串。
源字符串必须以 ‘\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
strcat 不可以自己追加自己，容易出现死循环。

示例：

#include <stdio.h>
#include <string.h>
int main()
{char arr1[20] = "hello \0xxxxxxxx";char arr2[] = "word";strcat(arr1, arr2);printf("%s\n", arr1);return 0;
}运行结果： hello word

2.2.2 strcat 函数模拟

#include <stdio.h>
#include <string.h>
char* my_strcat(char* dest, const char* str)
{//1.找目标空间中的\0char* cur = dest;while (*cur != '\0'){cur++;}//2.拷贝源头数据到\0之后的空间while (*cur++ = *str++)  //*str++ 优先级都是一样的情况下，先右到左{;}return dest;
}
int main()
{char arr1[20] = "hello \0xxxxxxxx";char arr2[] = "word";printf("%s\n", my_strcat(arr1, arr2));return 0;
}运行结果：hello word 

2.3 strcmp

2.3.1 strcmp 函数介绍

extern int strcmp(const char *s1,const char *s2);

strcmp 是比较字符串的库函数，头文件是 #include <string.h>，比较的是对应位置上字符的大小（ASCII码值的大小）而非长度
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

示例：

#include <stdio.h>
#include <string.h>
int main()
{/*char arr1[] = "abcdef";char arr2[] = "abc";*//*char arr1[] = "abc";char arr2[] = "abcd";*/char arr1[] = "abc";char arr2[] = "abc";int ret = strcmp(arr1, arr2);if (ret > 0)printf("arr1>arr2\n");else if (ret < 0)printf("arr1<arr2\n");elseprintf("arr1==arr2\n");printf("%d\n", ret);return 0;
}//运行结束：//等于 ret = 0 

2.3.2 strcmp 函数模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
//方法一
/*int my_strcmp(const char* s1, const char* s2)
{assert(s1 && s2);while (*s1 == s2){if (*s1 == '\0'){return 0;}*s1++;*s2++;}if (*s1 > *s2)return 1;elsereturn -1;
}*///方法二
int my_strcmp(const char* s1, const char* s2)
{assert(s1 && s2);while (*s1 == *s2){if (*s1 == '\0'){return 0;}s1++;s2++;}return *s1 - *s2;//返回两个字符ASCII相减的值
}int main()
{/*char arr1[] = "abcdef";char arr2[] = "abc";*/char arr1[] = "ad";char arr2[] = "aa";/*char arr1[] = "abc";char arr2[] = "abc";*/int ret = my_strcmp(arr1, arr2);if (ret > 0)printf("arr1>arr2\n");else if (ret < 0)printf("arr1<arr2\n");elseprintf("arr1==arr2\n");printf("%d\n", ret);return 0;
}//运行结果：arr1>arr23

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

3.1 strncpy 函数介绍

char *strncpy(char *destinin, char *source, int maxlen);

strncpy 的头文件是 #include <string.h>
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加NULL，直到num个

示例：

#include <stdio.h>
#include <string.h>
int main()
{char arr1[20] = "abcdefrtjujghbv";char arr2[] = "xxxx12";char arr3[] = "qwertyuio";strncpy(arr1, arr2, 7);printf("%s\n", arr1);strncpy(arr1, arr3, 3);printf("%s\n", arr1);return 0;
}//运行结果：xxxx12qwex12

3.2 strncat 函数介绍

char * strncat(char *dest, const char *src, size_t n);

strncat 的头文件是 #include <string.h>
strncat 和 strncpy 的使用非常相似，strncat是追加num个字符从源字符串到目标空间。
strncat 追加完成后会自己添加\0。
strncat 可以自己追加自己

示例：

#include <stdio.h>
#include <string.h>
int main()
{char arr1[20] = "abcdef";char arr2[] = "xyz";strncat(arr1, arr2, 2);printf("%s\n", arr1);strncat(arr2, arr2, 5);printf("%s\n", arr2);return 0;
}//运行结果：abcdefxyxyzxyz

3.3 strncmp 函数介绍

int strncmp(const char *str1, const char *str2, size_t n)

strmcpy 的头文件是 #include <string.h>
strncmp 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
如果返回值 < 0，则表示 str1 小于 str2。
如果返回值 > 0，则表示 str2 小于 str1。
如果返回值 = 0，则表示 str1 等于 str2。

示例：

#include <stdio.h>
#include <string.h>
int main()
{char arr1[20] = "abcdef";char arr2[] = "abd";int ret = strcmp(arr1, arr2, 3);printf("%d\n", ret);return 0;
}//运行结果：
-1

4. 字符串查找

4.1 strstr

4.1.1 strstr 函数介绍

char * strstr ( const char *str1, const char * str2);

strstr 字符串查找函数，头文件是 #include <string.h>，在一个字符串中查找另外一个字符串是否存在，如果存在，则返回子串第一次出现的位置；不存在，则返回NULL。
如果找到了该子串，会从找到的地方开始输出

示例：

#include <stdio.h>
#include <string.h>
int main()
{char arr1[] = "abcdefabcdef";char arr2[] = "def";char* p = strstr(arr1, arr2);if (p == NULL){printf("不存在\n");}else{printf("%s\n", p);}return 0;
}//运行结果：defabcdef

4.1.2 strstr函数模拟实现

#include <stdio.h>
#include <string.h>
char* my_strstr(const char* str1, const char* str2)
{const char* s1 = str1;const char* s2 = str2;const char* p = str1;while (*p){s1 = p;s2 = str2;while ((*s1 != '\0') && (*s2 != '\0') && (*s1 == *s2)){s1++;s2++;}if (*s2 == '\0'){return (char*)p;//找到了}p++;}return NULL;//找不到子串
}
int main()
{char arr1[] = "abcdefabcdef";char arr2[] = "fab";char* p = my_strstr(arr1, arr2);if (p == NULL){printf("不存在\n");}else{printf("%s\n", p);}return 0;
}//运行结果:fabcdef	

4.2 strtok 函数介绍

char *strtok(char s[], const char *delim);

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

示例：

#include <stdio.h>
#include <string.h>
int main()
{char arr[] = "[e-mail]";char buf[100] = { 0 };strcpy(buf, arr);//将数据拷贝一份，处理buf中arr数组的内容const char* sep = "@.o";//sep定义了用作分隔符的字符集合char* str = NULL;for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep)){printf("%s\n", str);}return 0;
}//运行结果：zhangsanqqcm

5. 字符分类函数

后续添加

6. 字符串转换函数

int tolower ( int c );
int toupper ( int c );转换函数把字母大写转换成字母小写；或者把字母小写转换成字母大写。
tolower 函数返回其参数对应的小写形式
toupper 函数返回其参数对应的大写形式
如果函数的参数并不是处于适当大小写状态的字符（即 toupper 的参数不是小写字母或者 tolower 的参数不是大写字母），函数将不修改参数直接返回。

示例：

后续添加

7. 内存操作函数

7.1 memcpy

7.1.1 memcpy函数介绍

void * memcpy ( void * destination, const void * source, size_t num );memcpy 是内存拷贝函数，头文件是 #include <string.h>；num的单位是字节。
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。
memcpy 的参数类型是void*可以接收任意类型的数据。

示例：

#include <stdio.h>
#include <string.h>
int main()
{int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0};memcpy(arr2, arr1, 20);//把arr1的前20个字节的数拷贝到arr2里面去，一个int是4字节int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr2[i]);}return 0;
}//运行结果：1 2 3 4 5 0 0 0 0 0

7.1.2 memcpy 函数模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* dest, void* src, size_t num)
{void* ret = dest;assert(dest);assert(src);//断言，让dest和src不为空指针while (num--){*(char*)dest = *(char*)src;//一个字节一个字节的处理dest = (char*)dest + 1;src = (char*)src + 1;}return ret;
}
int main()
{int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0};my_memcpy(arr2, arr1, 20);//把arr1的前20个字节的数拷贝到arr2里面去int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr2[i]);}return 0;
}//运行结果：1 2 3 4 5 0 0 0 0 0

7.2 memmove

7.2.1 memmove 函数介绍

void * memmove ( void * destination, const void * source, size_t num );memmove和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
memcpy 只需要实现不重叠的拷贝就可以了。
memmove 是需要实现重叠内存的拷贝。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

示例：

#include <stdio.h>
#include <string.h>
int main()
{int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };memmove(arr1+2, arr1, 20);int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr1[i]);}return 0;
}//运行结束：1 2 1 2 3 4 5 8 9 10

7.2.2 函数模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memmove(void* dest, void* src, size_t num)
{void* ret = dest;assert(dest);assert(src);//断言，让dest和src不为空指针if (dest < src)//1 前->后{while (num--){*(char*)dest = *(char*)src;//一个字节一个字节的处理dest = (char*)dest + 1;src = (char*)src + 1;}}else //2 3 后->前{while (num--){*((char*)dest + num) = *((char*)src + num);}}return ret;
}
int main()
{int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };my_memmove(arr1+2, arr1, 20);int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr1[i]);}return 0;
}

7.3 memcmp 函数介绍

int memcmp(const void *str1, const void *str2, size_t n);memcmp 的头文件是 #include <string.h>
memcmp 比较从ptr1和ptr2指针开始的num个字节。一个字节一个字节比较。
str1-- 指向内存块的指针。
str2-- 指向内存块的指针。
n-- 要被比较的字节数。 
strcmp是比较字符大小，这个是比较字节大小。

示例：

#include <stdio.h>
#include <string.h>
int main()
{int arr1[] = { 1,2,3,4,5 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00...int arr2[] = { 1,2,3,0,0 };//01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00...int ret = memcmp(arr1, arr2, 13);printf("%d\n", ret);return 0;
}//运行结果：1

7.4 memset 函数介绍

void *memset(void *s, int ch, size_t n);memset 内存设置函数，头文件 #include <stdio.h>
将 ptr 设置为 value 值，num个字节。以字节为单位修改内存。
函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法 [1]  。
memset()函数原型是extern void *memset(void *buffer, int c, int count) buffer：为指针或是数组,c：是赋给buffer的值,count：是buffer的长度.

示例：

#include <stdio.h>
#include <string.h>
int main()
{int arr[5] = { 1,2,3,4,5 };memset(arr, 0, 9);int i = 0;for (i = 0; i < 5; i++){printf("%d ", arr[i]);}return 0;
}

7.4 memset 函数介绍

void *memset(void *s, int ch, size_t n);memset 内存设置函数，头文件 #include <stdio.h>
将 ptr 设置为 value 值，num个字节。以字节为单位修改内存。
函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法 [1]  。
memset()函数原型是extern void *memset(void *buffer, int c, int count) buffer：为指针或是数组,c：是赋给buffer的值,count：是buffer的长度.

示例：

#include <stdio.h>
#include <string.h>
int main()
{int arr[5] = { 1,2,3,4,5 };memset(arr, 0, 9);int i = 0;for (i = 0; i < 5; i++){printf("%d ", arr[i]);}return 0;
}