目录
励志环节
发光并非太阳的专利，大家都可以。
本章重点
重点介绍处理字符和字符串的库函数的使用和注意事项
求字符串长度 strlen
长度不受限制的字符串函数 strcpy strcat strcmp
长度受限制的字符串函数介绍strncpy strncat strncmp
字符串查找 strstr strtok
错误信息报告 strerror
字符操作
内存操作函数 memcpy memmove memset memcmp
C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在
常量字符串中或者字符数组中。
字符串常量 适用于那些对它不做修改的字符串函数.
一 函数介绍
1.1 strlen
在前面的文章中，介绍了三种方法实现strlen:(1)计数器的方法（2）递归的方法 (3)指针-指针的方法。
size_t strlen ( const char * str );
sizeof 是一个操作符，返回的结果为size_t （size_t专门为sizeof的返回值设计的）
size_t 相当于unsigned int
库函数strlen返回值 是size_t,所以 strlen 不能用于加减：strlen("abc") - strlen("abcdefg") 结果会是一个size_t 类型的数，不会是-4 (解决办法，可以强制转换）
字符串以'\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )
参数指向的字符串必须要以 '\0' 结束。
注意函数的返回值为size_t，是无符号的（ 易错 ）
学会strlen函数的模拟实现
1.2 strcpy
char* strcpy(char * destination, const char * source );
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。（strlen不管目标空间可以可以放进去，但是我们要保证目标空间足够大，以便能放进去）
目标空间必须可变。
学会模拟实现
1.3 strcat
追加一个字符串
char * strcat ( char * destination, const char * source );
源字符串必须以 '\0' 结束。没有\0的话，就无法追加，打印不出来。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串自己给自己追加，如何？
代码展示：
#include <stdio.h>
int main()
{
char arr1[30] = "hello";
char arr2[] = "world";
strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
1.4 strcmp
int strcmp ( const char * str1, const char * str2 );
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字strcmp(s1, s2),比较字符串的大小，两个字符串从左向右逐个字符相比（按ASCII的值大小相比），直到某一个字符不相等或者其中一个字符串比较完毕才停止比较，字符的比较为ASCII码的比较（若字符串1大于字符串2，返回结果大于0，若字符串1小于字符串2，返回结果小于0，若字符串1等于字符串2，返回结果等于0.）
strcmp的头文件是<string.h>
1.5 strncpy
char * strncpy ( char * destination, const char * source, size_t num );
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加'\0'，直到num个。
1.6 strncat
char * strncat ( char * destination, const char * source, size_t num )
追加字符，追加num个字符从源字符串到目标空间。
如果源字符串的长度大于num，则追加num个源字符串之后，再在后边一个加'\0'。如果源字符串的长度小于num，则追加完源字符串之后，再在后边加一个'\0'，别的就不管了。
1.7 strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
比较num个字符
1.8 strstr
char * strstr ( const char *str1, const char * str2);
字符串查找函数，在str1中找str2,返回在str1中第一次出现str2的地址。找不到返回空指针。
代码展示：
#include <stdio.h>
int main()
{
char arr1[] = "abcdabcd";
char arr2[] = "cd";
char* ret = strstr(arr1, arr2);
if (ret == NULL)
printf("找不到");
else
printf("%s\n", ret);
return 0;
}
1.9 strtok
char * strtok ( char * str, const char * sep );
（1）sep参数是个字符串，定义了用作分隔符的字符集合
（2）第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
（3）strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改。）
把标记内容改成\0，会改变字符串的内容，所以把字符串临时拷贝。
（4）strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串 中的位置。
（5）strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。
（6）如果字符串中不存在更多的标记，则返回 NULL 指针。
1 strtok函数找第一个标记的时候，函数的第一个参数不是NULL
2 strtok函数找非第一个标记的时候，函数的第一个参数是NULL
代码展示：
#include <stdio.h>
int main()
{
const char* p = "@.";
char arr[] = "abxbcbhd@nckdc.cidhc";
char buf[50] = { 0 };//因为字符串会被修改，所以要吧arr临时拷贝到buf里
//要保证arr不被修改
strcpy(buf, arr);//临时拷贝
char* str = strtok(buf, p);
printf("%s\n", str);
str = strtok(NULL, p);
printf("%s\n", str);
str = strtok(NULL, p);
printf("%s\n", str);
return 0;
}
代码展示：（这个代码更加的方便）
#include <stdio.h>
int main()
{
const char* p = "@.";
char arr[] = "abxbcbhd@nckdc.cidhc";
char buf[50] = { 0 };//因为字符串会被修改，所以要吧arr临时拷贝到buf里
//要保证arr不被修改
strcpy(buf, arr);//临时拷贝
char* str = NULL;
for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
{
printf("%s\n", str);
}
return 0;
}1.10 strerror
char * strerror ( int errnum );
返回错误码，所对应的错误信息（把错误码翻译成错误信息）
C语言中规定了一些信息
错误码—错误信息
0—No Error
1— …
2—…
当库函数使用的时候，发生错误的时候会把errno这个全局的错误变量设置为本次执行库函数产生的错误码。
errno是C语言提供的全局变量，可以直接使用，放在errno.h 这个文件，所以要引用
#include <errno.h> strerror(errno);就会把错误显示出来
代码展示：
#include <stdio.h>
int main()
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%s\n", strerror(i));
}
return 0;
}
字符分类函数
上图为字符分类函数，例如：isspace,如果是空白字符，就返回非0。不是空白字符就返回0。
别的和这个用法差不多。
代码展示：
#include <stdio.h>
#include <ctype.h>
int main()
{
printf("%d\n", isspace(' '));
return 0;
}
字符转换函数
int tolower(int c);
int toupper(int c);
#include <stdio.h>
int main()
{
char ch = 0;
ch = getchar();
if (islower(ch))
{
ch = toupper(ch);
}
else
{
ch = tolower(ch);
}
printf("%c\n", ch);
return 0;
}大小写转换
1.11 memcpy
void * memcpy ( void * destination, const void * source, size_t num );
（1）函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
（2）这个函数在遇到 '\0' 的时候并不会停下来。
（3）如果source和destination有任何的重叠，复制的结果都是未定义的。如果destination在source的后面，就可能会导致刚改变的destination的内容，又变成了source. 就会导致重复。这种情况建议使用memmove，就不会发生。
代码展示：
#include <stdio.h>
int main()
{
char arr1[] = "sjhjcd";
char arr2[50] = { 0 };
strcpy(arr2, arr1);//拷贝字符串
int arr3[] = { 1, 2,3,4,5,6,7 };
int arr4[5] = { 0 };
memcpy(arr4, arr3, 20);//这个什么都可以拷贝，不确定拷贝什么
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", arr4[i]);
}
return 0;
}
C语言只要求memcpy能拷贝不重叠的的内存空间就足够了，memmove去处理那些重叠的内存空间。但是VS 的memcpy可以处理重叠的内存拷贝，也可以处理不重叠的内存拷贝。
1.12 memmove
void * memmove ( void * destination, const void * source, size_t num );
（1）和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
（2）如果源空间和目标空间出现重叠，就得使用memmove函数处理。
memmove 也可以处理不重叠的。
1.13 memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
（1）比较从ptr1和ptr2指针开始的num个字节
（2）返回值如下：
比较的是字节，相等的话，返回0。 比较的是ASCII值。
1.14 memset
代码展示：
#include <stdio.h>
int main()
{
char arr[20] = { 0 };
memset(arr, 'x', 10);
return 0;
}以字节为单位改。
二 库函数的模拟实现
2.1 模拟实现strlen
1 计数器的方法
#include <stdio.h>
#include <assert.h>
int my_strlen(const char* str)
{
assert(str);
int count = 0;
while (*str != '\0')
{
count++;
str++;
}
return count;
}
int main()
{
int len = 0;
len = my_strlen("abcdefg");//传递给my _strlen的是字符'a'的地址
printf("%d", len);
return 0;
}\0 的ASCII码值是 0 ，一个表示字符串结束的标志，这是一个转义字符，整体视为一个字符，在内存中的存储为0000 0000
字符在内存中是以ASCII码值对应的二进制的补码存在的（8位）
2.2 模拟实现strcpy
代码展示：
#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* a, const char* b)
{
assert(a && b);
char* ret = a;
while (*a++ = *b++)//++的优先级大于*的优先级
{
;
}
return ret;
}
int main()
{
char arr1[20] = { 0 };
char arr2[] = "hello";
printf("%s\n", my_strcpy(arr1, arr2));//函数的链式访问
return 0;
}尽量不要返回局部变量的地址（调用的那个函数，里面的局部变量，使用完就可能被销毁了，地址指向的局部变量的值，可能就变了），而不是局部变量。
2.3 模拟实现strcat
代码展示：
#include <stdio.h>
#include <assert.h>
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[30] = "hello";
char arr2[] = "world";
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}思路：（1）找到目标空间中的\0 (2)追加字符
everyting——搜索strcat——右击 打开路径
2.4 模拟实现strstr
代码展示：
#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* str1, const char* str2)
{
assert(str1 && str2);
if (*str2 == '\0')
{
return (char*)str1;//(const char* 和char*还是不同的）
}
//当第一个字符出现匹配，后续字母中出现不匹配的时候，字符串的地址要回到出现匹配的第一个字符，的下一个字符的地址，
//所以尽可能不要直接用str1和str2，而是间接的使用
const char* s1 = str1;
const char* s2 = str2;
const char* s3 = str1;//遇到匹配的第一个字符前一直在+1
while (*s3)//在这个循环里，s3一直在+1，一直到s3遇到\0 ，while结束
{
s1 = s3;
s2 = str2;
while (*s1 != '\0' && *s2 != '\0' && * s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
return (char*)s3;
s3++;
}
return NULL;
}
int main()
{
char arr1[] = "abcdabcd";
char arr2[] = "A";
char* ret = my_strstr(arr1, arr2);
if (ret == NULL)
printf("找不到");
else
printf("%s\n", ret);
return 0;
}2.5 模拟实现strcmp
代码展示：
#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1 == *str2)
{
if (*str1 == '\0')
{
return 0;
}
str1++;
str2++;
}
if (*str1 > *str2)
return 1;
else
return -1;
}
int main()
{
char arr1[] = "abc";
char arr2[] = "abcd";
int ret = my_strcmp(arr1, arr2);
printf("%d", ret);
return 0;
}"abcd" 和"abc"比较，是1 因为，第一个字符串是d的ASCII，后一个字符串是'\0'的ascii，所以是1.
2.6 模拟实现memcpy
代码展示：
#include <stdio.h>
#include <assert.h>
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 arr3[] = { 1, 2,3,4,5,6,7, 8, 9, 10 };
int arr4[5] = { 0 };
my_memcpy(arr4, arr3, 20);
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", arr4[i]);
}
return 0;
}知识点：
（1）void* 不能进行加减，所以转换成char *进行加减。
2.7 模拟实现memmove
代码展示：
#include <stdio.h>
#include <assert.h>
void* my_memmove(void* dest, const 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;
}
#include <stdio.h>
int main()
{
int arr3[] = { 1, 2,3,4,5,6,7, 8, 9, 10 };
my_memmove(arr3+1, arr3, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr3[i]);
}
return 0;
}
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
