C语言进阶---字符串+内存函数
本章重点
重点介绍处理字符和字符串的库函数的使用和注意事项。
- 求字符串长度
- strlen()
- 长度不受限制的的字符串函数
- strcpy()
- strcat()
- strcmp()
- 长度受限制的的字符串函数
- strncpy()
- strncat()
- strncmp()
- 字符串查找
- strstr()
- strtok()
- 错误信息报告
- strerror()
- 字符操作
- 内存操作函数
- memcpy()
- memmove()
- memset()
- memcmp()
前言
C语言中对字符的字符串的处理很频繁，但是C语言本身是没有字符串类型的，字符串通常放在
常量字符串中或者字符数组中。
字符串常量适用于那些对它不做修改的字符串函数。
1、字符串函数
1.1、strlen()—统计字符串长度
//头文件
size_t strlen(const char* str);
- 首先传的参数需要是个指针类型的。
- 字符串以
'\0'作为结束标志，strlen()函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）。 - 参数指向的字符串必须要以
'\0'结束。 - 注意函数的返回值为size_t，是无符号整型的
- 学会strlen()函数的模拟实现。
1.2、strcpy()—字符串拷贝
//头文件
char* strcpy(char* destination, const char* source)
- 源字符串必须以
'\0'结束。 - 会将源字符串中的
'\0'拷贝到目标空间。 - 返回值为目标字符串的首字符地址。
- 目标空间必须足够大，以确保能存放源字符串。
- 目标空间必须可变。
- 学会模拟实现。
简单使用介绍：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
char name[20] = { 0 };
strcpy(name, "zhangsan");
printf("%s\n", name);
return 0;
}
输出：
1.3、strcat()—字符串追加
//头文件
char* strcat(char* destination, const char* source)
- 源字符串必须以
'\0'结束。 - 源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有
\0，那就直接从这个位置开始追加。 - 目标空间必须有足够的大，能容纳下源字符串的内容。
- 目标空间必须可修改
1、简单使用介绍：
#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
char arr2[20] = "hello ";
strcat(arr2, "world");
printf("%s\n", arr2);
return 0;
}
输出：
2、这里说明一下：源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有\0，那就直接从这个位置开始追加。
如下代码：“hel\0lo”，中间位置有个\0，所以在追加"world"是，就直接从"hel"初开始追加了。最后输出结果就是:
“helworld”。
#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
char arr2[20] = "hel\0lo ";
strcat(arr2, "world");
printf("%s\n", arr2);
return 0;
}
输出：
2、模拟实现：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
char* my_strcat(char* dest, const char* source)
{
char* ret = dest;
assert(dest && source);
//1、找到目标字符串的\0。
while (*dest != '\0')
{
dest++;
}
//2、拷贝
while (*dest++ = *source++)
{
;
}
return ret;
}
int main()
{
char arr1[20] = "hello ";
my_strcat(arr1, "world");
printf("%s\n", arr1);
return 0;
}
那能不能实现字符串自己给自己追加？如下：
答案：是不能的。
int main()
{
char arr1[20] = "hello ";
my_strcat(arr1, arr1); //如何实现这样的效果呢？
printf("%s\n", arr1);
return 0;
}
1.4、strcmp()—比较字符串大小
//头文件
int strcmp(const char* str1, const char* str2);
- 返回值：
- 第一个字符串<第二个字符串，就返回小于0的数字
- 第一个字符串=第二个字符串，就返回0
- 第一个字符串>第二个字符串，就返回大于0的数字
那具体是怎么比较的呢？是依次比较各个字符串中字符的ASCII值。
比如：首先arr1中的字符’a’和arr2中的字符’a’进行比较，发现ASCII一样，然后再比较字符’b’…
之后当比较到arr1中的字符’d’和arr2中的字符’f’是，发现arr2中的’f’的ASCII值比arr1中的’d’的ASCII值大。
所以最终结果为arr2大。
char arr1[] = "abcd";
char arr2[] = "abcf";
1、简单使用：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
char arr1[] = "abcd";
char arr2[] = "abcf";
int ret = strcmp(arr1, arr2); //arr1小于arr2
if (ret < 0)
printf("<\n");
else if (ret == 0)
printf("=\n");
else
printf(">\n");
return 0;
}
输出：
2、模拟实现：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
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[] = "abcd";
char arr2[] = "abcf";
int ret = my_strcmp(arr1, arr2);
if (ret < 0)
printf("<\n");
else if (ret == 0)
printf("=\n");
else
printf(">\n");
return 0;
}
//判断>或者<的返回值还可以在优化：
//将下面一段代码替换为最后一行优化的代码
if (*str1 > *str2)
return 1;
else
return -1;
//替换这个优化的代码
return *str1 - *str2;
关于以上库函数不安全的说明
上面所说到了库函数，其实是相对不安全的，比如：
#include
#include
int main()
{
char arr1[] = "abcd";
char arr2[] = "abcdfr";
//arr2的字符长度比arr1的字符长度长，当让arr2拷贝到arr1时，arr1数组会放不下，
//放不下编译器也会放，那就呆滞了越界访问，以至于改变了其它内存中的数据，这是相当危险的。
strcpy(arr1, arr2);
return 0;
}
那这个时候，就应用诞生了相对来说安全一点的库函数：长度受限制的的字符串函数。
长度受限制的字符串函数是什么意思呢？下面介绍：
1.5、strncpy()–长度受限制拷贝
int strncmp ( const char * str1, const char * str2, size_t num );
多个参数：num。这个参数就是限制长度的参数，比如说让arr2的字符串拷贝到arr1中去，但是只允许拷贝3个字节的字符:
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
char arr1[] = "aaaaa";
char arr2[] = "bbbbb";
//让arr2的数据拷贝到arr1中去，但是只拷贝3个字节。
strncpy(arr1, arr2,3);
printf("%s\n", arr1);
return 0;
}
输出：
可以看到输出结果：只会将arr2中的前3个字符拷贝到arr1中，arr1前3个也字符会改变，并且后面的字符不会改变。
1.6、strncat()—长度受限制追加
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
char arr1[20] = "hello\0xxxxxx";
char arr2[] = "world";
strncat(arr1, arr2, 3);
printf("%s\n", arr1);
return 0;
}
输出：这里有个点要注意以下：在使用strncat()时，在追加完毕后，会自动在目标字符串末尾添加一个\0表示一个字符的结束。
这里采用调试查看：
1.7、strncmp()—长度受限制比较
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abc";
strncmp(arr1, arr2, 3); //只比较3个字符，结果应该为相等。
return 0;
}
1.8、strstr()—查找子串
const char * strstr ( const char * str1, const char * str2 );
参数说明：
- str1是母字符串的地址
- str2是子串的地址
比如现在有两个字符串：
char arr1[] = "abcdef";
char arr2[] = "cde"
strstr(arr1,arr2);
需要在arr1（母字符串）中寻找有没有arr2（子串）的内容。首先arr2中的字符串内容为：“cde”，而arr1中的字符串：“abcdef”，正好全部包含"cde"。那么此时strstr()函数会返回arr1中包含子串的首字符地址。也就是会返回arr1中字符c的地址。那如果我们在以%s打印时，就会将arr1的"cdef"的值全部打印出来，因为从起始位置’c’到’\0’结束，就是"cdef"。
所以strstr()函数的返回值是个char*类型的。
如果没有查找到字串，就会返回一个NULL指针。
1、使用演示：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
char arr1[] = "abcdef";
char arr2[] = "cde";
char* ret = strstr(arr1, arr2);
if (ret == NULL)
{
printf("没有找到\n");
}
else
{
printf("%s\n", ret);
}
return 0;
}
输出：
1.9、strtok()—切割字符串
char* strtok(char* str, const char* sep);
-
sep参数是个字符串，定义了用作分隔符的字符集合。
比如现在有一个字符串：“[email protected]”，假如字符
@和字符.就是我们分隔符，通过这两个符号，可以将字符串切割为一段一段的。那我们就可以这样定义这个sep参数：const char* sep = "@."; -
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分隔的标记。
这里的第一个参数就是要切割的字符串：
char arr[] = "[email protected]"; -
strtok函数找到了str中的下一个标记，并将其用
\0结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容没那个，并且可修改。）strtok函数找到了str中的下一个标记这句话的意思就是说，strtok找到了@分隔符，就会把@分隔符变为'\0'，那arr数组就会变成如下的样子：char arr[] = "zhengbo\0helloworld.com";然后
返回一个指向这个标记的指针，就是把分隔好的字符串：“zhengbo\0”，通过返回字符'z'的地址，作为指针返回过去。但是这样我们会发现一个问题：就是会把arr数组里面的内容给修改。那如果下面程序还需要使用arr数组呢？那情况就不对。所以说我们先应该使用strcmp()函数把arr数组给临时拷贝一份给另外一个数组，然后把临时拷贝的数组交给strtok来进行操作，那这样既能提取出来分隔的字符串，又能不对原数组arr进行修改。具体实现如下代码：
#include#include int mian() { const char* sep = "@."; char arr[] = "[email protected]"; char cp[30] = { 0 }; strcmp(cp,arr); //临时拷贝一份 strtok(cp, sep); //对临时拷贝的数组进行分隔 return 0; } -
strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
这个是说，我们在首次使用strtok函数时，需要传第一个参数，因为第一个参数里面保存了分隔符的地址，有了一个参数后，函数将找到str中第一个标记，也就是说找到了
@标记（分隔符），然后返回首字符z的地址，作为函数返回值，然后保存下来。 -
strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
到这一步，再次调用strtok函数，需要找第二个，第三个，第四个分割符的时候就不需要传第一个参数了，所以到这个地方我们就能明白，只有在找第一个分隔符的时候才传第一个参数。好，那问题又来了：那不传第一个参数，如何找到，下一个需要分割为字符串的首字符地址呢？原因是这样的：其实在找到第一个分隔符之后，NULL指针表示一种状态，NULL指针会记录着上一个分割后的起始位置，也就已经记着了第一个分隔符后面的字符地址了。然后在根据sep中记录的分隔符，分割出一段字符串。
-
如果字符串中不存在更多的标记，则返回NULL指针。
到这一步，是说，在真个arr数组里面没找到分隔符，那就直接strtok函数返回NULL指针。
1、效果演示：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
//创建分隔符集合
const char* sep = "@.";
//待分割的字符串
char arr[] = "[email protected]";
//创建一个临时数组
char cp[30] = { 0 };
//拷贝一份临时数据
strcpy(cp,arr);
//切割出zhengbo@，并把@换为\0了，且把z字符的地址，返回给了ret。
char* ret = strtok(cp, sep);
//打印出：zhengbo
printf("%s\n", ret);
//打印helloworld，这里的NULL指针表示一种状态，NULL指针记录了'h'的地址
ret = strtok(NULL, sep);
printf("%s\n", ret);
//打印com，这里NULL指针记录了'c'的地址
ret = strtok(NULL, sep);
printf("%s\n", ret);
return 0;
}
输出：
2、优化：上面的代码分割一个字符串就需要打印一次，其实这里可以写个for循环，来优化下代码：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
const char* sep = "@.";
char arr[] = "[email protected]";
char cp[30] = { 0 };
//拷贝一份临时数据
strcpy(cp,arr);
//切割出zhengbo@，并把@换为\0了，且把z字符的地址，返回给了ret。
char* ret = NULL;
//优化部分
for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep))
{
printf("%s\n", ret);
}
return 0;
}
1.10、strerror()
返回错误码，所对应的错误信息。
//头文件：
char* strerror (int errnum);
在C语言中，库函数在执行失败的时候，都会设置错误码。
虽说设置的都有错误码，但是我们怎么样才能知道错误码所对应的错误信息呢？
这个时候strerror()函数就起作用了。只需要把错误码传参进去，这个函数就会返回错误码所对应错误信息字符串的首字符地址。
1、代码演示：
//在X86平台上运行
#include
#include
int main()
{
printf("%s\n", strerror(0));
printf("%s\n", strerror(1));
printf("%s\n", strerror(2));
printf("%s\n", strerror(3));
return 0;
}
输出：
2、情景演示
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
//使用fopen()表示打开一个文件，并且r表示以只读的方式进行。
//如果打开成功会返回一个指针，如果打开失败会返回NULL指针。
//现在本地没有test.txt文件，所以会打开文件失败，返回NULL指针。
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
//errno是C语言中设置一个全局变量，用来专门存放错误码的。
printf("%s\n", strerror(errno));
return 1;
}
return 0;
}
输出：
2、字符分类函数
| 函数 | 如果它的参数符合下列条件就返回真 |
|---|---|
| iscntrl | 任何控制字符 |
| isspace |
空白字符：空格’ ‘，换页’\f’，换行’\n’，回车’\r’，制表符’\t’，垂直制表符’\v’ |
| isdigit |
十进制数字0~9 |
| isxdigit | 十六进制数字，包括所有十进制数字，小写字母af，大写字母AF |
| islower | 小写字母a-z |
| isupper | 大写字母A-Z |
| isalpha | 字母az或AZ |
| isalnum | 字母或数字，az、AZ、0~9 |
| ispunct | 标点符号，任何不属于数字或字母的图形字符（可打印） |
| isgraph | 任何图形字符 |
| isprint | 任何可打印字符，包括图形字符和空白字符 |
3、字符转换函数
字符转换：
1、tolower()-------------将大写字母转为小写
int tolower(int c); //将大写字母转为小写，如果传参数表示大写字母，给什么值，输出什么值。
代码演示：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
printf("%c\n", tolower('A'));
return 0;
}
输出：
2、toupper()----------------将小写字母转为大写
int toupper(int c); //将小写字母转为大写，如果传参数表示小写字母，给什么值，输出什么值。
代码演示：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
printf("%c\n", toupper('g'));
return 0;
}
输出：
4、内存操作函数
4.1、memcpy函数—内存拷贝（不能用来拷贝重叠内存）
void* memcpy (void* destination, const void* source, size_t num);
- 函数memcpy从source的位置开始向后复制num个__字节__的数据到destination的内存位置。
- 这个函数在遇到’\0’的时候并不会停下来。
- 如果source和destination有任何的重叠，复制的结果都是未定义的。
上面讲到字符函数也有两个拷贝：strcpy、strncpy。
但是这两个库函数都是指针字符串进行拷贝的。
那现在有两个整型数组，如何拷贝呢？
比如：
- int arr1[] = {1,2,3,4,5,6};
- int arr2[10] = {0};
这个时候就需要使用memcpy()库函数了。
在介绍这个库函数前，先来思考一下这个库函数诞生的原因：如果需要拷贝字符类型的数据用到了strcpy、strncpy函数，那如果需要拷贝整型数据的呢？需要产生一个专用于整型拷贝的库函数吗？如果需要拷贝浮点型呢？如果需要拷贝结构体呢？不可能说都会产生一个对应的拷贝库函数。
而是说直接用一个memcpy()函数，这个函数是直接对内存进行操作的，它拷贝的是内存块里面的数据。而无论是字符还是整形，或者是浮点型，再或者是结构体。它们的数据都是存放在内存中的。所以说可以直接用memcpy()函数进行统一拷贝操作。
1、参数介绍：
//头文件
void * memcpy ( void * destination, const void * source, size_t num );
- destination目标地址
- source 源地址
- 参数num的单位是字节。
2、代码演示：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
int arr1[] = { 1,2,3,4,5,6,7 };
int arr2[10] = { 0 };
//因为一个整型是4个字节，arr1里面有7个整型数字，所以是28个字节，
//memcpy的三个参数num的单位是字节，所以应传参28
//将arr1的数据拷贝到arr2中
memcpy(arr2, arr1, 28);
return 0;
}
调试查看：
3、模拟实现memcpy()函数
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
void* my_memcpy(void* dest, const void* src, size_t num)
{
assert(dest && src);
//用于返回目标地址。
void* ret = dest;
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7 };
int arr2[10] = { 0 };
//因为一个整型是4个字节，arr1里面有7个整型数字，所以是28个字节，
//memcpy的三个参数num的单位是字节，所以应传参28
my_memcpy(arr2, arr1, 28);
return 0;
}
4.2、memmove函数------内存拷贝（可以用来重叠内存之间的拷贝）
memcpy函数和memmove函数基本功能大致一样，但是memmove有个比memcpy强大的小功能：
1、memcpy函数是不能用来处理重叠的内存之间的数据拷贝。
2、memmove函数是可以处理重叠内存之间的数据拷贝的。
3、 memcpy只是memmove的一个子集。
memmove函数的参数和memmove函数的参数是一样的：
//头文件
void * memmove ( void * destination, const void * source, size_t num );
既然参数一样，那两个函数的用法也是一样的。
假如如下是数组arr1重叠部分：
下面来实现内存重叠的代码演示：
#include
#include
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1, arr1 + 2, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
输出：
4.3、memcmp—内存比较
//头文件
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
- num参数是字节。
- 比较从ptr1和ptr2指针开始的num个__字节__。
- 返回值如下：
- ptr1内存块中存储的数据比ptr1内存块中存储的数据大，就返回>0的值
- ptr1内存块中存储的数据比ptr1内存块中存储的数据小，就返回<0的值
- 如果将所指定的num字节全部比较完毕后，还是一样的大小，会返回0.
1、代码演示：
#include
#include
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,3,2 };
//这里num为12，表示比较12个字节的内容，一个int占用4个字节，所以一共比较3个数字。
int ret = memcmp(arr1, arr2, 12);
printf("%d\n", ret);
return 0;
}
输出：
分析：是如何比较出来大小的呢？
首先arr1中的数字在内存中是这样存储的：
01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
然后arr2中的数字在内存中是这样存储的：
01 00 00 00 03 00 00 00 02 00 00 00
因为我们指定了只比较12个字节的数据，所以两个数组开始从头比较，直到比较到第五个字节（如下图）：
arr1的数据是02，arr2的数据是03。这样一来比较大小就有了结果。是arr2大。所以返回-1<0的值。
4.4、memset—内存设置
void * memset ( void * ptr, int value, size_t num );
参数说明：
- ptr：需要填充的内存块的地址。
- value：要被填充的内容，（看着是int类型的，其实可以传char类型的数据，因为字符在内存中存储也是按照ASCII值存储的）。
- num：要被填充多少个字节。
1、代码演示：
#include
#include
int main()
{
char arr[] = "hello bbo";
//表示，从整个字符数组首字符开始，一直填充5个'x'字符。
memset(arr, 'x', 5);
printf("%s\n", arr);
return 0;
}
输出：
