C字符串 | 字符串处理函数 | 使用 | 原理 | 实现

1.字符串的定义

字符串是一系列字符组成的序列，C语言中字符串以\0结尾。由""引起的的字符串常量系统默认会添加\0，区分而由''引起的是字符常量。

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

int main()
{
    // 方式1：
    char* str1 = "";
    // 方式2：
    char arr1[] = "hello"; // 系统会默认添加一个\0，注意比较arr1和arr2
    char arr2[] = {'h','e','l','l','o'};
    char arr3[] = ""; // 默认一个\0
    // 方式3：
    char* str2 = (char*)malloc(128 * sizeof(char));
    strcpy(str2,"hello world");

    // 注意比较：strlen 和 sizeof的不同
    printf("use sizeof to calculate : char arr1[] = %ld\n",sizeof(arr1));
    printf("use strlen to calculate : char arr1[] = %ld\n",strlen(arr1));

    printf("use sizeof to calculate : char arr2[] = %ld\n",sizeof(arr2));
    printf("use sizeof to calculate : char arr3[] = %ld\n",sizeof(arr3));

    printf("%s\n",str2);
    
    return 0;
}

2.函数的使用

字符串函数传入参数的一个特点类似A of B 的格式，A of B表示B的A。以strcpy为例，传入的参数第一个是destination，第二个是source。是将source拷贝到destination中。

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

这里和Linux命令是相反的，例如，cp命令：前面的是原文件（source_file），后面的是目标文件（destination_directory）

cp [OPTION]... source... directory

3.strlen使用与实现

strlen的使用很简单，只需要传入一个char*的指针即可。

size_t strlen ( const char * str )

示例代码：

int main()
{
    const char* str1 = "hello world";
    char str2[] = "hello";

    // %u 是用于格式化输出无符号整数，%zu 格式化输出size_t
    printf("%u %u\n",strlen(str1),strlen(str2));

    return 0;
}

其实strlen的原理也比较简单，字符串是一个字符序列，strlen的工作就是统计一个一个字符，直到遇到\0。实现strlen有三种方式：
方式1：可以使用一个count计数器来统计。一层循环直到遇到\0结束。

size_t my_strlen1(const char* str)
{
    size_t count = 0;

    while(*str != '\0')
    {
        count++;	// 计数器++
        str++;		// 指针++
    }
    return count;
}

方式2：利用指针的加减特性，记录当前位置的地址，然后将指针指到\0位置，减去起始位置。

size_t my_strlen2(const char* str)
{
    const char* start = str; // 记录起始位置
	// 求'\0'的位置
    while (*str != '\0')
    {
        str++;
    }
    return str - start;  // 指针相减
}

方式3：使用函数递归，根据递归的三部曲：1.确定递归函数的参数和返回值 2.确定终止条件 3.确定单层递归的逻辑。这里可以简单的思考，让my_strlen3是一个黑盒，给一个char*的指针就能帮我求出字符串的长度。比如求：求"abc"的长度就要，求"bc"长度 + 1，如果求"bc"就可以又交给my_strlen3函数。

size_t my_strlen3(const char* str)
{
    if(*str == '\0') return 0;
    return 1 + my_strlen3(str + 1);
}

4.strcpy使用与实现

strcpy需要注意的点在于，确保destination的空间足够大，并且可以被修改。当然既然是指针就要保证不能使用空指针。

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

函数的实现：
实现函数困惑的点，soure以\0标志结尾，destination又要把\0拷贝，怎么实现。

void my_strcpy(char* distination,const char* sourse)
{
    while(sourse != '\0')
    {
        *(distination++) = *(sourse++);
    }
}

如果像上面这样实现程序，并没有把结束标志的\0拷贝到distination，如果打印distination会出现Segmentation fault (core dumped)

 printf("%s\n",distination);

让sourse赋值给distination然后再去判断\0。其实\0、0、NULL、false本质都是0，0值会判断为假，就退出循环。这里就很巧妙。

void my_strcpy(char* distination,const char* sourse)
{
    while(*(distination++) = *(sourse++))
    {
        ; 
    }
}

其实上面的版本就能实现字符串的拷贝，但如果传入一个NULL，就发生空指针解引用。不能指望程序员来严格遵守规则，需要在程序中避免错误。改进版本:

void my_strcpy(char* distination,const char* sourse)
{
    const char* ret = sourse;   	// 好习惯
    assert(distination != NULL);    // 断言，false就进入函数就报错，错就是错，对就不报错
    assert(sourse != NULL);

    while(*(distination++) = *(ret++))
    {
        ; 
    }
}

5.strcat的使用与实现

strcat是一个字符串处理函数，当然要遵守C字符串的风格的特点，如：字符串的结尾是\0。使用strcat和strcpy的使用特点基本一样，要求destination可以修改，并且要求空间足够大。当然如果详细的用法还是需要查看文档！

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

strcat函数的使用：

int main ()
{
    char arr[128] = "hello";
    strcat(arr," world");

    printf("%s\n",arr);
    return 0;
}

strcat函数的实现

char *my_strcat(char* destination,const char* source)
{
	// 记录destination其实位置，最后返回。
    char * ret = destination;

    assert(destination != NULL);
    assert(source != NULL);
	
	// 将destination移动到\0处
    while (*destination != '\0')
    {
        destination++;
    }
    
	// strcpy拷贝的逻辑
    while(*(destination++) = *(source++)){}
    
    return ret;
}

6.strcmp的使用与实现

strcmp用来比较字符串的大小，标准规定，标准是这样规定，但编译器尊不遵守那就不一定了！

• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字

int strcmp ( const char * str1, const char * str2 )

模拟实现：

int my_strcmp(const char* str1,const char* str2)
{
    assert(str1 != NULL);
    assert(str2 != NULL);

    while(* str1 != '\0' && *str2 != '\0')
    {
        if(*str1 > * str2) {return 1;}
        else if(*str1 < *str2) {return -1;}
        else 
        {
            str1++;
            str2++;
        }
    }
    if(str1 == '\0' && str2 =='\0') return 0;
    else if(str1 == '\0' && str2 !='\0') return -1;
    else return 1;
}

上面一看就是我写的，而下面的版本更加的巧妙

int my_strcmp(const char *src, const char *dst)
{
    int ret = 0;
    assert(src != NULL);
    assert(dst != NULL);

    
    while (!(ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
        ++src, ++dst;
    if (ret < 0)
        ret = -1;
    else if (ret > 0)
        ret = 1;
    return ret;
}

7.strstr的使用与实现

const char * strstr ( const char * str1, const char * str2 );
      char * strstr (       char * str1, const char * str2 );

简单使用：

int main()
{
    const char* str1 = "take it easy,the all things will be ok!";
    const char* str2 = "easy";

    if(strstr(str1,str2) != NULL)
    {
        printf("存在\n");
    } 
    else 
    {
        printf("不存在\n");
    }
    return 0;
}

模拟实现：

char* my_strstr(const char* str1,const char* str2)
{
    char* ret = (char*)str1;
    if(*str2 == '\0') return ret;
    char *s1,*s2; 

    while (* ret != '\0')
    {        
        // 给第二层循环使用
        s1 = ret;
        s2 = (char*)str2; 

        while(*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
        {
            s1++;
            s2++;
        }

        // s2到结尾了，说明已经找到了
        if(*s2 == '\0'){return ret;}	// ret表示返回匹配的第一个字符的地址
        ret++;
    }
    
    return NULL;
}

8.memcpy的使用和实现

memcpy函数是按照字节的方式来拷贝的，遇到 \0的时候并不会停下来。如果source和destination有任何的重叠，复制的结果都是未定义的。
函数的使用：

struct person
{
    char name[128];
    int age;
}person;

int main()
{
    const char* name = "i am lihua";
    memcpy(&person.name,name,strlen(name) + 1);

    int age = 0;
    memcpy(&person.age,&age,sizeof(int));

    printf("name = %s : age = %d\n",person.name,person.age);
    return 0;
}

模拟实现：
实现的思路也比较简单，source按照一个字节一个字节拷贝到destination，需要注意一点是要将void*强转成char*，char就是一个字节。

void *my_memcpy(void* destination,const void* source,size_t num)
{
    void* ret = destination;

    while(num--)
    {
        *(char*)destination = *(char*)source;
        destination++;
        source++;
    }
    return ret;
}

9.memmove的使用和实现

int main()
{
    char str[] = "memmove can allow memory cover";

    char *ret = (char *)my_memmove(str + 20, str + 15, 10);

    puts(ret);

    return 0;
}

模拟实现

void *my_memmove(void *destination, void *sourse, size_t num)
{
    void *ret = destination;

    if (destination <= sourse || destination >= sourse + num)
    {
        while (num--)
        {
            *(char *)destination = *(char *)sourse;
            destination++;
            sourse++;
        }
    }
    else
    {
        destination = destination + num - 1;
        sourse = sourse + num - 1;

        while (num--)
        {
            *(char *)destination = *(char *)sourse;
            destination--;
            sourse--;
        }
    }
    
    return ret;
}