字符串函数和内存函数

一、 字符串函数

库函数中，比较常见的是字符串函数和内存函数，今天我们一起来了解一下这些知识吧！

1.1 求字符串长度

(1) strlen

size_t strlen( const char *string );

描述：统计的是\0之前出现的字符的个数
注意项：
1、一定要保证计算的字符串有\0
2、库里面的strlen的返回类型是size_t的（因为长度不可能是负数），但是当需要运算两个字符串长度相减的时候，就可能是负的了，因为库函数是size_t，所以答案可能会把负的变成正的，导致错误，这时可以强制类型转换或者自己写一个。
strlen的模拟实现：
strlen有三种模拟实现的方法，请参照以下的代码！

#include<assert.h>
size_t my_strlen1(const char* str)
{
    assert(str != NULL);
    int count = 0;
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
        
}
size_t my_strlen2(const char* str)
{
    assert(str != NULL);
    if (*str != '\0')
        return 1 + my_strlen(++str);
    else
        return 0;
}

size_t my_strlen3(const char* str)
{
    assert(str != NULL);
    const char* start = str;
    while (*str)
    {
        str++;
    }
    return str - start;
}

1.2 长度不受限制的字符串函数

所谓长度不受限制，也就是拷贝、追加、比较的时候是把整个字符串全部进行。

(1)strcpy

char* strcpy( char *strDestination, const char *strSource );

描述：拷贝，把目的地的字符串覆盖掉
注意项：
1、把源头的数据拷贝到目的地，源头必须要有\0，strcpy遇到\0会停止拷贝，并且把\0也拷贝过去！
2、要把目的地的空间设置的足够大，能够容纳源字符串，否则会越界，非法访问。
3、目标空间必须可修改。（如果char* p = “abcdefgh”;，此时这个字符串是常量字符串，不可被修改，不能当作目的地！）
strcpy的模拟实现：

#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
    assert(dest && src);
    char* ret = dest;
    while(*dest++=*src++)
    {
        ;
    }
    return ret;
}

(2)strcat

char* strcat(char* strDestination,const char* strSource);

描述：在目的地后面追加一个字符串
注意项：
1、目标空间串要有一个\0，从该位置往后追加
2、源字符串也要有\0，这是停止的位置
3、源字符串要足够大，放得下所有字符
4、目标空间必须可修改
5、自己给自己追加的时候会出问题！因为把自己的\0g给替换掉了，陷入死循环。
strcat的模拟实现：

#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
    assert(dest && src);
    char* ret = dest;
    //1. 找目标空间的\0
    while (*dest)
    {
        dest++;
    }
    //2. 追加
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}

(3)strcmp

int strcmp( const char *string1, const char *string2 );

描述：用来比较字符串的大小的
注意项：
1、比较的是对应位置上的大小，如果该位置大小相同，（如a和a），则比较下一个位置，比如abc就是小于abd
2、第一个字符串比第二个字符串大就返回一个>0的数字，小则返回一个<0的数字，相等则返回0。（在vs上分别是1，-1，0）
strcmp的模拟实现：

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

1.3 长度受限制的字符串函数

因为长度不受限制的字符串函数可能会越界，不太安全，所以有了长度受限制的字符串函数。所谓长度受限制，也就是拷贝、追加、比较的时候仅仅进行n个字节。

(1)strncpy

char *strncpy( char *strDest, const char *strSource, size_t count );

描述：拷贝指定个数的字符，把目的地的字符覆盖掉
注意项：
1、把源头的count个数据拷贝到目的地，strncpy拷贝了count个字符停止拷贝，\0不会拷贝过去！！！
2、要把目的地的空间设置的足够大，能够容纳count个字符，否则会越界，非法访问。
3、目标空间必须可修改。
如果char* p = “abcdefgh”;，此时这个字符串是常量字符串，不可被修改，不能当作目的地。
4、如果传过去的count比源字符串的字符个数多，那么剩余的会拷贝\0过去
strncpy的应用代码：

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "qqqqqqqqqq";
	char arr2[] = "abcd";
	strncpy(arr1, arr2, 4);
	printf("%s\n", arr1);
	return 0;
}
//输出的结果为abcdqqqqqq

(2)strncat

char *strncat( char *strDest, const char *strSource, size_t count );

描述：追加count个字符到目的字符串后面
注意项：
1、目标空间串要有一个\0，从该位置往后追加
2、源字符串追加了count个字符后会停止，并且会在后面再加一个\0
3、源字符串要足够大，放得下count个字符
4、目标空间必须可修改
5、自己给自己追加的时候会出问题！因为把自己的\0g给替换掉了，陷入死循环。
6、如果传过去的count比源字符串的字符个数多，那么剩余的会拷贝\0过去
strncat的应用代码：

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[20] = "qqqqqqqqqq";
	char arr2[] = "abcd";
	strncat(arr1, arr2, 4);
	printf("%s\n", arr1);
	return 0;
}
//输出结果为qqqqqqqqqqabcd

(3)strncmp

int strncmp( const char *string1, const char *string2, size_t count );

描述：比较count个字符的大小
注意项：
1、比较的是对应位置上的大小，如果该位置大小相同，（如a和a），则比较下一个位置，比如abc就是小于abd
2、第一个字符串比第二个字符串大就返回一个>0的数字，小则返回一个<0的数字，相等则返回0。（在vs上分别是1，-1，0）
3、一共只会比较count次
strncmp的应用代码：

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "abce";
	char arr2[] = "abcd";
	int ret = strncmp(arr1, arr2, 4);
	printf("%d\n", ret);
	return 0;
}
//输出的结果是1，大于零的数，说明arr1大于arr2

1.4 字符串查找

(1)strstr

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

描述：在第一个串里找第二个字符串
注意项：
1、在第一个串里找第二个字符串，找到返回第二个字符串在第一个字符串里第一次出现的位置（是地址）
2、找不到返回空指针
strstr的模拟实现：

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

(2)strtok

char *strtok( char *str, const char *sep );

描述：这是用来切割字符串的

注意项：
1、sep参数是个字符串，定义了用作分隔符的字符集合
2、第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
3、strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
4、strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
5、strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。也就是说只有第一次切割的时候要传buf，此后只要传空指针。（因为它有static的变量，可以记录上次保存的地址）
6、如果字符串中不存在更多的标记，则返回 NULL 指针。
7、分割符除了\0所有的都可以，这是自己定义的！
strtok的两种应用代码：

#include<string.h>
#include<stdio.h>
int main()
{
    char arr[] = "abcdefgh@yeah.net";
    char* p = "@.";
    char buf[20] = {0};
    strcpy(buf, arr);
    char* pf = strtok(buf, p);
    printf("%s\n", pf);
    pf = strtok(NULL, p);//只有第一次切割的时候要传buf，此后只要传空指针
    printf("%s\n", pf);
    pf = strtok(NULL, p);
    printf("%s\n", pf);
    return 0;
}

这样写的代码有些繁琐，所以我们一般写成以下的形式：

#include<string.h>
#include<stdio.h>
int main()
{
    char arr[] = "abcdefgh@yeah.net";
    char* p = "@.";
    char buf[20] = {0};
    strcpy(buf, arr);
    char* pf = NULL;
    for(pf = strtok(buf, p); pf != NULL; pf = strtok(NULL, p))
    {
        printf("%s\n", pf);    
    }
    return 0;
}

1.5 错误信息报告

(1)strerror

char*strerror(interrnum);

描述：C语言的库函数在运行的时候如果发生错误，会产生一个变量errno存放错误码，错误码是一些数字，我们需要将错误码翻译成错误信息。

strerror的应用代码：

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
    //打开文件
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    //读文件
    //关闭文件
    fclose(pf);
    return 0;
}

假设我们的对应路径中没有叫做test.txt的文件，那么就会打开错误，此时我们不知道错误信息是什么，如果使用strerror函数，则能得到一个错误信息：No such file or directory，我们就能知道不存在相关的文件。

(2)perror

void perror( const char *string );

描述：直接打印错误信息，在打印错误信息前会打印你输入的自定义的信息
perror函数的应用代码：

#include<stdio.h>
#include<string.h>
int main()
{
    //打开文件
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
        perror("fopen");
        return 1;
    }
    //读文件
    //关闭文件
    fclose(pf);
    return 0;
}

输出结果是No such file or directory

1.6 字符操作

(1)字符分类函数

函数	如果其参数符合下列条件则返回真
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	任何可打印字符，包括图形字符和空白字符

注意项：
1、以上几个函数的头文件都是ctype.h，并且它们的参数都一样，都是int型的（因为char类型转换成ASCII码也是一个数字，所以字符也是可以当作参数的）
2、如果是真则返回非零数字，如果是假则返回零
应用代码：
选择其中一个来进行示范：

#include<stdio.h>
#include<ctype.h>
int main()
{
	int c = 'a';
	int ret = islower(c);
	printf("%d\n", ret);
	return 0;
}
//我的编译器输出的结果是2，则证明了'a'是小写字母

其他的几个函数的使用都是类似的！

(2)字符转换函数

函数	描述
toupper	把小写字符转换成大写字符
tolower	把大写字符转换成小写字符

注意项：
1、这两个函数的参数也是int型的，和上面的字符分类函数一样
2、头文件也是ctype.h
3、返回值就是它转换完成后的结果
应用代码：

#include <stdio.h>
#include <ctype.h>
int main()
{
	int i = 0;
	char str[] = "Test String.\n";
	char c;
	while (str[i])
	{
		c = str[i];
		if (isupper(c))
			c = tolower(c);
		putchar(c);
		i++;
	}
	return 0;
}
//输出的结果是全部小写，test string.

二、内存操作函数

(1)memcpy

void *memcpy( void *dest, const void *src, size_t count );

描述：因为strcpy只能拷贝字符串，拷贝别的就得用memcpy了。
注意项：
单位是字节！
memcpy的应用代码：

#include<memory.h>
int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr2[10] = { 0 };
    memcpy(arr2, arr1+2, 20);
    return 0;
}

memcpy的模拟实现：

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的时候可能会出错，可能会得到重复的数据，比如：

本应得到1 2 1 2 3 4 5 7 8 10，但却得到1 2 1 2 1 2 1 8 9 10，要想解决这个问题，就得使用memmove函数了，可以说memmove函数是memcpy函数更加完善的版本。

(2)memmove

void *memcpy( void *dest, const void *src, size_t count );

注意项：
单位是字节！
memmove的模拟实现：

void* my_memmove(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    if (dest < src)
    {
        //前-->后
        while (num--)
        {
            *(char*)dest = *(char*)src;
            ++(char*)dest;
            ++(char*)src;
        }
    }
    else
    {
        //后-->前
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    return ret;
}

(3)memset

void *memset( void *dest, int c, size_t count );

描述：以字节为单位来设置内存中的数据，把内存中从dest位置开始的count个字节设置为c
注意项：
第二个参数必须是字符！（数字也行，只要是整型家族的都可以，但根据ASCII码表要有意义）
memset的应用代码：

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[] = "abcdefghijk";
    memset(arr1, 97, 5);
    printf("%s\n", arr1);
    return 0;
}

(4)memcmp

int memcmp( const void *buf1, const void *buf2, size_t count );

描述：比较大小，用法和strncmp差不多，但是单位是字节
注意项：
1、buf1>buf2返回大于0的数字
2、buf1=buf2返回0
3、buf1<buf2返回小于0的数字
memcmp的应用代码：

#include<stdio.h>
#include<string.h>
int main()
{
	int arr1[10] = { 1,1,1,1,1,1,1,1,1,1 };
	int arr2[10] = { 2,2,2,2,2,2,2,2,2,2 };
	int ret = memcmp(arr1, arr2, 20);
	printf("%d\n", ret);
	return 0;
}
//输出结果是-1，则说明在前20个字节当中，arr1比arr2小