2021-08-29 string functions are used and parsed（字符串函数的使用和剖析）

#include<stdio.h>

#include<string.h>

int main()

{

char a1[5] = “abc”;

char a2[] = “hello bit”;

strncpy(a1, a2,4);// 因为 a1只能放得下 5个字符，所以至多只能放五个元素

// 但是 如果我们把目的地 的 ‘\0’，给覆盖掉了，在打印%s的时候，

//打印完hello之后。就会出现乱码，所以 我选择拷贝 4个字符

// 因为 打印 %s， 遇到’\0’才会停值打印，要不然它就往后一直找’\ 0’,从而输出乱码

// 如果这五个元素中，没有’\0’，拷贝完成后，是不会在后面补’\0’

// 意思就是你让我拷贝多少个，我就拷贝多少个

// 只要输入正确的 拷贝字符个数，就能避免 因 目的地空间 太小，拷贝内容放不下而造成的程序崩溃。

// 换句话理解 就是 不完全拷贝，只是拷贝部分字符串

printf(“%s\n”, a1);// hell

return 0;

}

程序二：

#include<stdio.h>

#include<string.h>

int main()

{

char a1[10] = “abcdefg”;

char a2[] = “bit”;

strncpy(a1, a2, 6);// 这里我想要拷贝 6个字符，但是 a2 只有 4个

// 那么拷贝过去的时候，不够就补’\0’,直到满足拷贝 字符个数

// a1[10]= “bit\0\0\0g\0”，最后一个’\0’是 a1 后面隐藏的 ‘\0’

printf(“%s\n”, a1);// bit

return 0;

}

模拟实现 strncpy 函数

---

#include<stdio.h>

#include<assert.h>

char* my_strncpy(char* destination, const char* source,size_t k)// 不需要改变source，用const修饰，可以避免意外更改，而且这样写程序更完美

{

assert(destination&&source);

char* tmp = destination;// 因为我需要观察 a1 是否拷贝成功，所以我们返回的是 destination 的起始地址

// 下面 destination 再循环完后，destination 不再是起始地址，所以需要先保存。

while (k && (*destination++ = *source++))// 在k–， 等于 3 时，

{ //再进下一步，source == ‘\0’,然后赋给destination

// 同时该表达式值 为 0，跳出循环，

//也就是说，进行了第四次拷贝时，没有进入循环体 k–；

// k应该等于 2 的，但此时 k == 3

k–;

}

if (k)

{

while (–k)//因为我们拷贝 6个字符，不够就补’\0’，已经拷贝4个字符，还差2个

{ // --k == 2.下一次就是 1，再下次，刚好等于0,跳出循环，至此，拷贝6个字符已全部完成

*destination++ = ‘\0’;

}

}

return tmp;// 返回目的地 的起始地址

}

int main()

{

char a1[10] = “abcdefg”;

char a2[] = “bit”;

printf(“%s\n”, my_strncpy(a1, a2,6));// bit

return 0;

}

strncat 函数

---

char* my_strncat(char* front, const char* back,size_t k)

程序一：

#include<stdio.h>

int main()

{

char a1[30] = “hello”;

char a2[] = “world”;

strncat(a1, a2, 3);// 追加字符串，那追加的肯定是 字符串,

// 这里要求追加 a2 前的三个字符的字符，也就说追加字符wor ，但是函数会在后面加 一个’\0’。

// 让成为 一个字符串 “wor”,这就是 strncat 的特点，

printf(“%s\n”, a1);

return 0;

}

程序二：

#include<stdio.h>

int main()

{

char a1[30] = “hello”;

char a2[] = “world”;

strncat(a1, a2, 8);// 把 world’ 赋给a1之后，strncat 函数它就不管了。

// strncpy不一样，strncpy 会补’\0’。

// 请理解记住

printf(“%s\n”, a1);

return 0;

}

模拟实现 strncat 函数

---

#include<stdio.h>

char* my_strncat(charfront, const charback,size_t k)

{

char* tmp = front;// 因为我需要观察 a1 是否追加成功，所以我们返回的是 front 的起始地址

// 下面 front 再循环完后，fornt 不再是起始地址，所以需要先保存。

while (*front++)// 找 ‘\0’，*front == ‘\0’，跳出循环，后置加加，加了一次

{

;

}

front–;// 因为后置加加，多加了一次，所以要减一次

while (k–)// 追加字符个数

{

if (!(*front++ = *back++))//在判断条件中进行追加，直到式子等于 ‘\0’ == 0，！（取反）为真，返回 front 起始地址，也就满足，追加完了，就完了，不会像strncpy 一样去’\0’

{

return tmp;

}

}

*front = ‘\0’;// strncat 函数 会在追加字符（不包含’\0’）后，加一个’\0’

return tmp;

}

int main()

{

char a1[30] = “hello”;

char a2[] = “world”;

printf(“%s\n”, my_strncat(a1, a2, 8));

return 0;

}

strncmp 函数 int strncmp(const char* str1,const char* str2,size_t count) count 字节个数；返回的值，与 strcmp 是一样的

---

#include<stdio.h>

#include<string.h>

int main()

{

const char* p1 = “abcdef”;

const char* p2 = “abcqwer”;

printf(“%d\n”,strncmp(p1, p2, 3));// 3 表达的意思是 比较前面 3 个字符

//因为前三个字符相同，所以返回值为 0

// 改成 4 的话，d 比 q小，返回 它们ASCII码值的差(gcc环境)

//在vs2013 环境中 返回 -1

return 0;

}

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

---

#include<stdio.h>

#include<string.h>

int main()

{

char* p = “abcdef”;

char* p2 = “def”;

char* ret = strstr(p,p2); // 判断 p2 是否为 p 的子符串，

//如果是，返回 p2 在 p 中第一次出现 的地址

//如果不是，返回空指针 NULL

if (ret == NULL)

{

printf(“p2 不是 p 的子串\n”);

}

else

{

printf(“p2 是 p 的子串 p= %s\n”,ret);

}

return 0;

}

模拟实现 strstr 函数

---

#include<stdio.h>

#include<assert.h>

char* my_strstr(const char* str1, const char* str2)

{

assert(str1&&str2);

if (!*str2)// *s2 == ‘\0’ == 0,为假，取反 为真， 执行if 语句，因为s2第一个元素为’\0’，就没有追加的必要了

{

return (char*)str1;// 因为 str1， 被const修饰了,，是受保护的，最好 转换一下类型

}

char* s = NULL;

char* s2 = NULL;

char* current = (char*)str1;// 因为 str1， 被const修饰了,，是受保护的，最好 转换一下类型

// 创建两个空指针 为下面的程序备用,接收两个数组的起始地址，同时防止 两地址被改变，而current，是为了记录子串的起始地址

while (*current) //*str1 不等于 ‘\0’,才能进入循环体

{

s = current;// 此时 s 指向 str1 起始地址

s2 = (char*)str2;// 因为 str2， 被const修饰了,，是受保护的，最好 转换一下类型

while ((*s == *s2)&& *s2 && *s)

// *s2 和 *s 等于 ‘\0’ 需要跳出，因为s 或者 s2 所有 元素 已判断完毕，此时 s 和 s2 完全相同，s2 和 s 互为对方的子集

// *s == ‘\0’ == 0 时，表示从current 指向的位置，不是子串的地址 ，需要current++，从下个位置继续判断，因为这个不是，但下一个可能是。

// 如果在运行过程当中 s2 等于 ‘\0’==0；但s 不等于或等于，说明 s 中 有 s2 这个子串

{

s++;

s2++;// 用来确定 两个字符串内容 从current指向的位置开始，往后的字符 是否相等

}

if (!*s2)// s2 == ‘\0’//current 指向 字符 d 时，执行完上循环s2 == ‘\0’ == 0 跳出时，代表着s2 是 s 的子串

{

return current;

}

current++;// 假如p1首元素地址 不是 子串（p2） 的首元素地址，p1current++，指向第二个元素，继续重复上述程序，继续判断子串

//依次类推，直到 current 指向 字符 d 时，p1首元素地址（current指向的位置） 是 子串（p2） 的首元素地址，并且p1有这 子串（p2）一样的的内容，才能说 p2 是 p1 的 子串（子集）

}

// 如果所有循环结束后，current 指向 ‘\0’（*curren== ‘\0’ == 0）

return NULL;// 找不到子字符串

}

int main()

{

char* p = “abbcdefghi”;

char* p2 = “def”;

if (my_strstr(p, p2) == NULL)

{

printf(“p2 不是 p 的子串\n”);

}

else

{

printf(“p2 是 p 的子串 p= %s\n”, my_strstr(p, p2));// yes

}

return 0;

}

strtok 函数 ： char* strtok(char* str，const char* sep);

---

sep 参数 是个 字符串，定义了 用作 分隔符 的 字符集合

1.第一个参数 指定 一个字符串，它包含了 0 个 或 多个 由 sep 字符串 中 一个 或者多个分隔符的标记

2，strtok函数 找到 str 中的下一个标记，并将其用 \0 结尾，返回一个 指向这个标记 的 指针。

（strtok 函数 会 改变 被操作的字符串，所以在使用 strtok 函数 切分 的 字符串 一般都是 临时拷贝的内容 并且 可修改）

3，strtok 函数的 第一个参数 不为 NULL，函数将找到 str 中 第一个标记，strtok 函数 将保存 它在字符串的位置

4. strtok 函数的 第一个参数 为 NULL，函数将在同一个字符串 中 被保存的位置开始，查找下一个标记。

5. 如果字符串 中 不存在 更多的 标记，则返回NULL 指针

举个例子：

192.168.31.121

192.168.31.121 - strtok 函数可以把 192 168 31 121 分别拿到

再举个例子

zpw@bitdu.tech zpw 邮箱名。 bitdu 域名 tech 域名后缀

程序一：

#include<stdio.h>

int main()

{

char arr[] = “zpw@bitdu.tech”;

char* p = “@.”;

char*buf[1024] = { 0 };

// 拷贝一份数据到 buf 里

strcpy(buf, arr);

//切割arr中的字符串

char*ret = strtok(arr, p); // 但是此方法，只能切割 已知 有多少个切割符

printf(“%s\n”,ret);

ret = strtok(NULL, p);

printf(“%s\n”, ret);

ret = strtok(NULL, p);

printf(“%s\n”, ret);

return 0;

}

程序二：

#include<stdio.h>

int main()

{

char arr[] = “zpw@bitdu.tech”;

char* p = “@.”;

char*buf[1024] = { 0 };

// 拷贝一份数据到 buf 里

strcpy(buf, arr);

//切割buf中的字符串

char*ret = NULL;

for (ret = strtok(arr, p); ret != NULL;ret = strtok(NULL,p))

{

printf(“%s\n”, ret);

}

return 0;

}

第一个进入这个 for 循环时，它就开始寻找切割点，找到了，将其用 \0 结尾，将其返回 指向 这个切割点（标记）的 指针， 因为 strtok 函数的 第一个参数 不为 NULL，函数将找到 str 中 第一个标记，strtok 函数 将保存 它在字符串的位置

判断条件，判断是否为空指针，不是就输出，下面的语句，再将其第一个参数 改为一个空指针，因为 strtok 函数的 第一个参数 为 NULL，函数将在同一个字符串 中 被保存的位置开始，查找下一个标记

如果字符串 中 不存在 更多的 标记，则返回NULL 指针，然后跳出循环，执行 return 0; 结束程序

程序三：

#include<stdio.h>

#include<assert.h>

int main()

{

char arr[] = “192.168.31.121”;

char* p = “.”;

char buf[1024] = { 0 };

strcpy(buf, arr);// 拷贝一份 arr 到 buf 里

char* ret = NULL;

for (ret = strtok(arr, p); ret != NULL; ret = strtok(NULL, p))

{

printf(“%s\n”, ret);

}

return 0;

}

strerror 函数 ： char* strerror(int errnum);

---

返回错误码，所对应的错误信息。（把 错误码 转换成 对应的错误信息，然后 返回 它的地址）

程序一：

#include<stdio.h>

int main()

{

char* str = strerror(0);

printf(“%s\n”, str);// No error 判断初始化有没有错误

return 0; // strerror(1) 则 输出为 Operation not permitted - 不允许 此操作

// strerror(2) 则 输出为 No such file or directory = 目录下 没有 此文件

// 。。。

// 0 1 2 错误码；每一个错误码 对应 一个错误信息，这个错误信息是用来描述 这个错误码的。

}

程序二：

#include<stdio.h>

#include<errno.h> // errno 是一个全局错误变量（错误码的变量），当C语言的库函数 在执行过程中，发生了错误，就会把对应的错误码赋值到errno中

int main()

{

char* str = strerror(errno);// strerror 函数 与 errno.h 头文件 搭配使用

printf(“%s\n”, str);

return 0;

}

程序三：

#include<stdio.h>

#include<string.h>

#include<errno.h>

int main()

{

//fopen 打开文件

FILE* pf= fopen(“test.txt”, “r”); // 打开 test.txt 文件， 打开方式"r" == read -> 读文件。

// 这个函数 打开的文件必须在,否则打开失败，返回的值 是一个 FILE*（file - 文件） 的指针

if (pf == NULL) // fopen 调用失败

{

printf(“%s\n”,strerror(errno));// 此刻 我们并没有 test.txt 文件

} // 怎么找这个文件呢？

// 来到 我们创建 该项目 的位置 进去，再进去到 与 该项目工程名 相同名字 的文件夹，在里面找这个文件

// 那肯定 是找不到的，返回一个 NULL

//输出为 No such file or directory == 没有 此文件 或 目录

else

{

printf(“open file success\n”); // 在对应的 文件下，创建一个 test.txt 文件，就可以输出这条语句

}

return 0;

}

字符分类函数 ：

---

函数           如果它的参数符合下列条件就返回真，否则，返回假

iscntrl                           任何控制字符

isspace         空白字符：空格’ ‘,换页’\f’,换行’\n’，回车’\r’,制表符’\t’ 或者 垂直制表符’\v’

isdigit                         十进制数字 0~9

isxdigit         十六进制数字，包括所有十进制数字，  小写字母a~f，大写字母 A~F

islower                       小写字母 a~z

isupper                       大写字母 A~Z

isalpha                     字母 a~ z 或 A~ Z

isalnum               字母或者数字，az，AZ，0~9

ispunct       标点符号，任何不属于数字或者字母的图形字符(可打印)

isgraph                     任何图形字符

isprint         任何可打印字符，包括图形字符和空白字符

程序一：

#include<stdio.h>

#include<ctype.h>

int main()

{

char ch = ‘w’;

printf(“%d\n”,islower(ch));// 如果是小写的，返回一个 非零值,

char ch1 = ‘W’;

printf(“%d\n”, islower(ch1)); //如果不是 小写字母，是其它的。则返回 0

int ret = isdigit(ch);// isdigital 判断函数是否为 十进制数，是, 就返回一个十进制数，不是，返回0

printf(“%d\n”, ret);// 0

return 0;

}

字符转换：

---

int tolower（int c） 转换为 小写 字母

nt toupper (int c) 转换为 大写 字母

程序一：

#include<stdio.h>

int main()

{

char ch = tolower(‘Q’);

putchar(ch);// q

printf(“\n”);

putchar(toupper(‘q’));// Q

return 0;

}

程序二：

#include<stdio.h>

int main()

{

char arr[]=“I am A student”;

int i = 0;

while (arr[i])

{

if (isupper(arr[i]))

{

arr[i] = tolower(arr[i]);

}

i++;

}

printf(“%s\n”, arr);// i am a student

return 0;

}

内存函数

---

memcpy

memmove

memcmp

memset

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

num 的单位是字节

1,函数 memcpy 从 source 的位置 开始向后复制 num 个字节的数据 到 destination 的 内存位置

2.这个函数在遇到’\0’的时候并不会停下来。

3. 如果 source 和 destination 有任何的重叠，复制的结果都是未定义的

程序一：

#include<stdio.h>

int main()

{

int arr1[] = { 1, 2, 3, 4, 5 };

int arr2[5] = { 0 };

memcpy(arr2,arr1,sizeof(arr1));// memcpy 函数 是一个字节一个字节拷贝的。arr1 是一个整型数组，数组的每一个元素都是整形，内存大小为 4 byte

// 所以用到了，sizeof 计算 arr1 的所占内存的大小。因为我们想要把 arr1 的字节内容 全部拷贝到 arr2 中。

int i = 0;

for (i = 0; i < 5; i++)

{

printf("%d ", arr2[i]);// 1 2 3 4 5

}

printf(“\n”);

return 0;

}

程序二：

#include<stdio.h>

struct s

{

char name[20];

int age;

};

int main()

{

struct s arr3[] = { { “张三”, 20 }, { “李四”, 30 } };

struct s arr4[3] = { 0 };

memcpy(arr4, arr3, sizeof(arr3));// memcpy 函数 是一个字节一个字节拷贝的。

printf(“%s,%d\n”, arr4[0].name, arr4[0].age);// 张三, 20

printf(“%s,%d\n”, arr4[1].name, arr4[1].age);// 李四, 30

return 0;

}

模拟实现 memcpy 函数

---

程序一：

#include<stdio.h>

#include<assert.h>

struct s

{

char name[20];

int age;

};

void* my_memcpy(void* destination, const void* source, size_t num)

{

assert(destination&&source);

void* ret = destination;

while (num–)

{

(char)destination = (char)source;

++(char*)destination;// 先转换类型，再加加

++(char*)source;

}

return ret;

}

int main()

{

struct s arr[] = { { “张三”, 20 }, { “李四”, 30 } };

struct s arr1[3] = { 0 };

int arr2[] = { 1, 2, 3, 4, 5 };

int arr3[5] = { 0 };

my_memcpy(arr1, arr, sizeof(arr));// 通过调试观察

my_memcpy(arr3,arr2, sizeof(arr2));

return 0;

}

程序二：

#include<stdio.h>

#include<assert.h>

void* my_memcpy(void* destination, const void* source, size_t num)

{

assert(destination&&source);

void* ret = destination;

while (num–)

{

(char)destination = (char)source;

++(char*)destination;

++(char*)source;

}

return ret;

}

int main()

{

int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

int i = 0;

//my_memcpy(arr+2,arr,20);// 想把 1,2,3,4,5 拷贝到 3,4,5,6,7 即 1, 2, 1，2, 3, 4, 5, 8, 9, 10

//memcpy 库函数可以实现，但是自己做的不行，为什么库函数能处理，

//那是因为 memcpy， 在C语言标准中，memcpy只需要处理 不重叠的内存拷贝就可以。所以我们模拟实现的函数功能不包括重叠情况

// memmove 在 c语言标准中， 处理重叠（不重叠）内存的拷贝

memmove(arr + 2, arr, 20);// 1， 2， 3， 4， 5. 6， 7， 8， 9， 10

for (i = 0; i < 10; i++)

{

printf("%d ", arr[i]);// 1 2 1 2 1 2 1 8 9 10 结果显然不行，这说明，在拷贝的过程中，数组前五个元素已经改变了。所以无法达到我们想要的效果

} // 出现重叠拷贝 -》 使用 memmove 函数( void* destination,const void* source,size_t count ) ，它是处理 内存重叠的 处理

return 0;

}

模拟实现 memmove

---

从这张图我们得知。destination 大于 source 的地址。 如果从前面往后（从 1 到 5）拷贝，会导致丢失 3，4，5 。

其运行过程 ： 1 2 3 4 5 6 7 8 9 10 -> 1 2 1 4 5 6 7 8 9 10 -> 1 2 1 2 5 6 7 8 9 10

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

， 在C语言标准中，memcpy只需要处理 不重叠的内存拷贝就可以。所以我们模拟实现的函数功能不包括重叠情况

// memmove 在 c语言标准中， 处理重叠（不重叠）内存的拷贝

memmove(arr + 2, arr, 20);// 1， 2， 3， 4， 5. 6， 7， 8， 9， 10

for (i = 0; i < 10; i++)

{

printf("%d ", arr[i]);// 1 2 1 2 1 2 1 8 9 10 结果显然不行，这说明，在拷贝的过程中，数组前五个元素已经改变了。所以无法达到我们想要的效果

} // 出现重叠拷贝 -》 使用 memmove 函数( void* destination,const void* source,size_t count ) ，它是处理 内存重叠的 处理

return 0;

}

模拟实现 memmove

---

从这张图我们得知。destination 大于 source 的地址。 如果从前面往后（从 1 到 5）拷贝，会导致丢失 3，4，5 。

其运行过程 ： 1 2 3 4 5 6 7 8 9 10 -> 1 2 1 4 5 6 7 8 9 10 -> 1 2 1 2 5 6 7 8 9 10

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-cT6Xzxwv-1710865789374)]
[外链图片转存中…(img-wsmTrUki-1710865789375)]
[外链图片转存中…(img-zvbirmQm-1710865789375)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-3ec2xTyN-1710865789376)]