字符函数和字符串函数

#include<assert.h>
size_t my_strlen(const char* str)
{
    size_t count = 0;
    assert(str);
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

2.strcpy（拷贝）

函数原型：char * strcpy(char * destination, const char * source)

源字符串必须以'\0'结束

会将源字符串中的'\0'拷贝到目标空间

目标空间必须足够大，以确保能存放源字符串

目标空间必须可变

模拟实现：

char* my_strcpy(char* dest, const char* src)
{
    assert(dest);
    assert(src);
    char* ret = dest;
    while (*src)
    {
        *dest++ = *src++;
    }
    *dest = *src;
    return ret;
}

3.strcat（字符串追加）

函数原型：char * strcat (char * destination, const char * source)

源字符串必须以'\0'结束

目标空间必须足够大，能容纳源字符串内容

目标空间必须可修改

模拟实现：

char* my_strcat (char* dest, const char* src)
{
    char* ret = dest;
    assert(dest && src);
    while (*dest != '\0')
    {
        dest++;
    }
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}

4.strcmp（字符串比较）

函数原型：int strcmp (const char * str1, const char str2)

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

第一个字符串等于第二个字符串，返回0

第一个字符串小于第二个字符串，返回小于0数字

模拟实现：

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;
}

5.strstr（字符串查找）

函数原型：char * strstr (const char * str1, const char * str2)

模拟实现：

char* my_strstr(const char* str1, const char* str2)
{
    assert(str1 && str2);
    const char* s1 = str1;
    const char* s2 = str2;
    const char* p = str1;
    while (*p)
    {
        s1 = p;
        s2 = str2;
        while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
        {
            return (char*)p;
        }
        p++;
    }
    return NULL;
}

6.strtok（字符串分割）

函数原型：char * strtok(char * str, const char * sep)

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

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

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

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

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

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

7.strerror（将错误码转换为错误信息）

函数原型：char * strerror(int errnum)

例：用的时候传errno，printf("%s\n", strerror(errno));

errno ——C语言设置的一个全局的错误码存放的变量

字符分类函数：

(如果他的参数符合下列条件就返回真)

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：任何可打印字符，包括图形字符和空白字符

8.memcpy（内存复制(确保数据无重叠)）

函数原型：void * memcpy(void * destination, const void * source, size_t num)

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

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

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

模拟实现：

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;
}

注：memcpy函数不是用来处理重叠的内存间的数据拷贝的，

使用memmove函数来实现重叠内存间的数据拷贝

9.memmove（内存复制）

函数原型：void * memmove (void * destination, const void * source, size_t num)

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

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

模拟实现：

void* my_memmove (void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* ret = dest;
    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;
}