本章重点

重点介绍处理字符和字符串的库函数的使用和注意事项。

求字符串长度
- strlen()
长度不受限制的的字符串函数
- strcpy()
- strcat()
- strcmp()
长度受限制的的字符串函数
- strncpy()
- strncat()
- strncmp()
字符串查找
- strstr()
- strtok()
错误信息报告
- strerror()
字符操作
内存操作函数
- memcpy()
- memmove()
- memset()
- memcmp()

前言

C语言中对字符的字符串的处理很频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

字符串常量适用于那些对它不做修改的字符串函数。

1、字符串函数

1.1、strlen()---统计字符串长度

//头文件<string.h>

size_t strlen(const char* str);

首先传的参数需要是个指针类型的。
字符串以'\0'作为结束标志，strlen()函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）。
参数指向的字符串必须要以'\0'结束。
注意函数的返回值为size_t，是无符号整型的
学会strlen()函数的模拟实现。

1.2、strcpy()---字符串拷贝

//头文件<string.h>

char* strcpy(char* destination, const char* source)

源字符串必须以'\0'结束。
会将源字符串中的'\0'拷贝到目标空间。
返回值为目标字符串的首字符地址。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。
学会模拟实现。

简单使用介绍：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

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

输出：

1.3、strcat()---字符串追加

//头文件<string.h>
char* strcat(char* destination, const char* source)

源字符串必须以'\0'结束。
源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有\0，那就直接从这个位置开始追加。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改

1、简单使用介绍：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

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 <stdio.h>

int main()
{
    char arr2[20] = "hel\0lo ";
    strcat(arr2, "world");
    printf("%s\n", arr2);
    return 0;
}

输出：

2、模拟实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>

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()---比较字符串大小

//头文件<string.h>
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 <stdio.h>
#include <string.h>

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 <stdio.h>
#include <string.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[] = "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 <stdio.h>
#include <string.h>

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 <stdio.h>
#include <string.h>

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 <stdio.h>
#include <string.h>

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 <stdio.h>
#include <string.h>

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 <stdio.h>
#include <string.h>

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参数是个字符串，定义了用作分隔符的字符集合。

比如现在有一个字符串："zhengbo@helloworld.com"，假如字符@和字符.就是我们分隔符，通过这两个符号，可以将字符串切割为一段一段的。那我们就可以这样定义这个sep参数：
```
const char* sep = "@.";
```

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

这里的第一个参数就是要切割的字符串：
```
char arr[] = "zhengbo@helloworld.com";
```

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 <stdio.h>
#include <string.h>
int mian()
{
    const char* sep = "@.";
    char arr[] = "zhengbo@helloworld.com";
    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 <stdio.h>
#include <string.h>
int main()
{
    //创建分隔符集合
    const char* sep = "@.";
    //待分割的字符串
    char arr[] = "zhengbo@helloworld.com";
    //创建一个临时数组
    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 <stdio.h>
#include <string.h>
int main()
{
    const char* sep = "@.";
    char arr[] = "zhengbo@helloworld.com";
    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()

返回错误码，所对应的错误信息。

//头文件：<errno.h>
char* strerror (int errnum);

在C语言中，库函数在执行失败的时候，都会设置错误码。

虽说设置的都有错误码，但是我们怎么样才能知道错误码所对应的错误信息呢？

这个时候strerror()函数就起作用了。只需要把错误码传参进去，这个函数就会返回错误码所对应错误信息字符串的首字符地址。

1、代码演示：

//在X86平台上运行

#include <stdio.h>
#include <errno.h>

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 <stdio.h>
#include <errno.h>

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	十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F
islower	小写字母a-z
isupper	大写字母A-Z
isalpha	字母a~z或A~Z
isalnum	字母或数字，a~z、A~Z、0~9
ispunct	标点符号，任何不属于数字或字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

3、字符转换函数

字符转换：

1、tolower()-------------将大写字母转为小写

int tolower(int c);     //将大写字母转为小写，如果传参数表示大写字母，给什么值，输出什么值。

代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>

int main()
{
    printf("%c\n", tolower('A'));
    return 0;
}

输出：

2、toupper()----------------将小写字母转为大写

int toupper(int c);     //将小写字母转为大写，如果传参数表示小写字母，给什么值，输出什么值。

代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>

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、参数介绍：

//头文件   <string.h>
void * memcpy ( void * destination, const void * source, size_t num );

destination目标地址
source 源地址
参数num的单位是字节。

2、代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

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 <stdio.h>
#include <string.h>
#include <assert.h>

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函数的参数是一样的：

//头文件   <string.h>
void * memmove ( void * destination, const void * source, size_t num );

既然参数一样，那两个函数的用法也是一样的。

假如如下是数组arr1重叠部分：

下面来实现内存重叠的代码演示：

#include <stdio.h>
#include <string.h>

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---内存比较

//头文件   <string.h>
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 <stdio.h>
#include <string.h>

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 <stdio.h>
#include <string.h>

int main()
{
    char arr[] = "hello bbo";
    //表示，从整个字符数组首字符开始，一直填充5个'x'字符。
    memset(arr, 'x', 5);
    printf("%s\n", arr);
    return 0;
}

输出：

C语言进阶---字符串+内存函数介绍

本章重点

前言

1、字符串函数

1.1、strlen()---统计字符串长度

1.2、strcpy()---字符串拷贝

1.3、strcat()---字符串追加

1.4、strcmp()---比较字符串大小

关于以上库函数不安全的说明

1.5、strncpy()--长度受限制拷贝

1.6、strncat()---长度受限制追加

1.7、strncmp()---长度受限制比较

1.8、strstr()---查找子串

1.9、strtok()---切割字符串

1.10、strerror()

2、字符分类函数

3、字符转换函数

4、内存操作函数

4.1、memcpy函数---内存拷贝（不能用来拷贝重叠内存）

4.2、memmove函数------内存拷贝（可以用来重叠内存之间的拷贝）

4.3、memcmp---内存比较

4.4、memset---内存设置

热门文章

最新文章

相关课程

相关电子书

相关实验场景