【C语言进阶】第三节：字符串+内存函数的介绍

1. strlen：获取字符串长度

• 字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0')。  
• 参数指向的字符串必须要以 '\0' 结束。
• 函数的返回值为size_t，是无符号的。

模拟实现：

size_t my_strlen(char* s)
{
    size_t count = 0;
    while (*s != '\0')
    {
        s++;
        count++;
    }
    return count;
}

int main()
{
    char* str = "abcdef";
    size_t sz = my_strlen(str);
    printf("%u\n", sz);
	return 0;
}

下面一段程序输出什么？

int main()
{
    const char* str1 = "abcdef";
    const char* str2 = "bbb";
    if (strlen(str2) - strlen(str1) > 0)
        printf("str1 > str2\n");
    else
        printf("str1 < str2\n");
    return 0;
}

str1 > str2

两个无符号类型相减还是无符号数，永远大于0

2. strcpy：复制字符串

• 源字符串必须以 '\0' 结束
• 会将源字符串中的 '\0' 拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串
• 目标空间必须可修改

模拟实现：

char* my_strcpy(char* dst, char* src)
{
    char* ret = dst;
    assert(dst != NULL);
    assert(src != NULL);
    while (*src != '\0')
    {
        *dst++ = *src++;
    }
    *dst = '\0';
    return ret;
}

int main()
{
    char arr1[20] = "hello world";
    char arr2[] = "xxxxx";
    my_strcpy(arr1, arr2);
    printf("%s\n", arr1);
    printf("%s\n", arr2);
    return 0;
}

3. strcat：连接字符串

• 源字符串必须以 '\0' 结束
• 目标空间必须足够大，以确保能存放源字符串
• 目标空间必须可修改

模拟实现：

char* my_strcat(char* dst, char* src)
{
    char* ret = dst;
    while (*dst != '\0')
    {
        dst++;
    }
    //最后一次把'\0'复制给dst再退出
    while (*dst++ = *src++)
    {
       ;
    }
    return ret;
}

int main()
{
    char arr1[20] = "hello ";
    char arr2[] = "world";
    my_strcat(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}

4. strcmp：比较两个字符串

返回值	表明
<0	第一个字符串小于第二个字符串
0	第一个字符串等于第二个字符串
>0	第一个字符串大于第二个字符串

模拟实现：

int my_strcmp(const char* str1, const char* str2)
{
    while (*str1 && *str2)
    {
        if (*str1 != *str2)
        {
            if (*str1 > *str2)
                return 1;
            else
                return -1;
        }
        str1++;
        str2++;
    }
    if (*str1 != '\0')
        return 1;
    else if (*str2 != '\0')
        return -1;
    else
        return 0;
}

int main()
{
    int ret = my_strcmp("bbc", "bbc");
    printf("%d\n", ret);
    return 0;
}

5. strncpy：从字符串中复制字符

• 从源字符串拷贝num个字符到目标空间
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加 '\0' ，直到num个
• 如果源字符串的长度大于num，则不会再目标空间追加 '\0'

例：（也是它和strcpy的不同）

int main()
{
    char arr1[20] = "xxxxxxxxxxx";
    char arr2[] = "abcdef";
    strncpy(arr1, arr2, 3);
    printf("%s\n", arr1);
    return 0;
}

int main()
{
    char arr1[20] = "xxxxxxxxxxx";
    char arr2[] = "abcdef";
    strncpy(arr1, arr2, 10);
    printf("%s\n", arr1);
    return 0;
}

6. strncat：从字符串附加字符

• 和strcat的不同就是多了一个参数num

7. strncmp：比较两个字符串的字符

• 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完

8. strstr：查找子字符串

模拟实现： 

char* my_strstr(const char* str1, const char* str2)
{
    //如果str2为空直接返回str1
    if (*str2 == '\0')
        return str1;

    char* cp = str1;
    char* s1 = str1;
    char* s2 = str2;
    while (*cp)
    {
        //cp指向str1中的那个字符就比较这个字符
        s1 = cp;
        //每次都要把s2重新指向str2最开始的字符
        s2 = str2;
        while (*s1 && *s2 && *s1 == *s2)
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
            return cp;
        cp++;
    }
    return NULL;
}

int main()
{
    char* str1 = "abbbcdef";
    char* str2 = "bbc";
    char* ret = my_strstr(str1, str2);
    if (ret != NULL)
        printf("%s\n", ret);
    else
        printf("找不到\n");
    return 0;
}

9. strtok：将字符串拆分为标记

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

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

• strtok函数找到str中的下一个标记，并将其用 '\0' 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

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

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

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

例：

int main()
{
    //在strtok函数中，str会被修改，所以一定是可修改的字符数组，不能是常量字符串
    char str[] = "- This, a sample string.";
    char* pch;
    const char* sep = " ,.-";

    pch = strtok(str, sep);
    while (pch != NULL)
    {
        printf("%s\n", pch);
        pch = strtok(NULL, sep);
    }
    return 0;
}

10. strerror：获取指向错误消息字符串的指针

• 返回错误码对应的错误信息

int main()
{
    FILE* pf = fopen("data.txt", "r");
    if (pf == NULL)
    {
        printf("fopen: %s\n", strerror(errno));
        perror("fopen");
        return 1;
    }

    fclose(pf);
    return 0;
}

字符分类函数：

字符转换函数：

//大写字母转小写字母
int tolower ( int c );
//小写字母转大写字母
int toupper ( int c );

11. memcpy：复制内存块

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

• 这个函数在遇到 '\0' 的时候并不会停下来

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

模拟实现：

void* my_memcpy(void* dst, const void* src, size_t num)
{
    void* ret = dst;
    while (num--)
    {
        *(char*)dst = *(char*)src;
        dst = (char*)dst + 1;
        src = (char*)src + 1;
    }
    return ret;
}

int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr2[20] = { 0 };
    my_memcpy(arr2, arr1, 10);
    for (int i = 0; i < 20; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

12. memmove：移动字符串

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的

• 如果源空间和目标空间出现重叠，就使用memmove函数处理

模拟实现：

void* my_memmove(void* dst, const void* src, size_t num)
{
    void* ret = dst;

    //分两种情况，防止出现覆盖有用数据的情况
    if (dst < src)
    {
        while (num--)
        {
            *(char*)dst = *(char*)src;
            ((char*)dst)++;
            ((char*)src)++;
        }
    }
    else
    {
        while (num--)
        {
            *((char*)dst + num) = *((char*)src + num);
        }
    }
    return ret;
}

int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    my_memmove(arr1 + 2, arr1, 20);
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

13. memcmp：比较两个内存块

•  比较从ptr1和ptr2指针开始的num个字节

例：

int main()
{
	char* str1 = "abcdef";
	char* str2 = "abcDef";
	int ret = memcmp(str1, str2, 6);
	if (ret > 0)
		printf("1 > 2\n");
	else if (ret < 0)
		printf("1 < 2\n");
	else
		printf("1 = 2\n");
	return 0;
}

小写字母的ascii码值大于大写字母，所以输出1 > 2