“探索内存与字符串的玄机：函数学习之路”

前言

C 语言中对字符和字符串的处理很是频繁，但是 C 语言本身是没有字符串类型的，字符串通常放在

常量字符串 （列如：“abcde”） 中或者 字符数组（char arr[10]="abcde"） 中。 字符串常量 适用于那些对它不做修改的字符串函数 .

1. 函数介绍

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

1.1 strlen

函数原型：size_t strlen ( const char * str );

在使用此函数需要注意入下几点：

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

实现方法有三种：计数器         递归           指针        三种方法

1.计数器

#include<assert.h>

size_t my_strlen(const char* start)
{
	assert(start != NULL);    //避免start为空指针
	int count = 0;
	while (*start++ != 0)    //++比*的优先级高
		count++;
	return count;
}

2.递归

size_t my_strlen(const char* start)
{
	assert(start != NULL);     //防止接收的指针为空指针导致出错
	if (*start != 0)            //如果指针指向的内容不为‘\0’则指针向后移动一位调用本身。
		return 1+my_strlen(start + 1);
	else                        //如果所指内容为‘\0’则返回0
		return 0;
}

3.指针

size_t my_strlen(const char* start)
{
	char* end = start;
	while (*end++ != 0);
	return(size_t)(--end - start);
}

1.2 strcpy

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

函数注意项：

• 源字符串必须以 '\0' 结束。
• 会将源字符串中的 '\0' 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。（不会检查目标空间是否能够撑下）
• 目标空间必须可变。
• 学会模拟实现

函数模拟

char* my_strcpy(char* start, const char* source)
{
	char* start1 = start;
	while (*start++ = *source++);
	return start1;
}

1.3 strcat

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

• 源字符串必须以 '\0' 结束。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。

函数模拟

char* my_strcat(char * arr, const char * arr1)
{
	char* start = arr;
	while (*arr != 0) ++arr;
	while (*arr++ = *arr1++);
	return start;
}

字符串自己给自己追加，如何？

会程序崩溃陷入死循环！

1.4 strcmp

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

注意事项：

• 标准规定：
• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字

函数模拟

int my_strcmp(const char * one,const char * tow)
{
	while (*one != 0 && *tow != 0)
	{
		if (*one > *tow)
			return -1;
		else if (*one < *tow)
			return 1;
		else
		{
			one++;
			tow++;
		}
	}
	if (*one == 0 && *tow!=0)
		return -1;
	else if (*tow == 0 && *one!=0)
		return 1;
	else
		return 0;
}

那么如何判断两个字符串？

应使用strcmp函数进行字符串中字符单独对比，如果使用字符串直接对比则对应的行为是用常量字符串地址相比较。

长度受限制的字符串

1.5 strncpy

函数原型： char * strncpy ( char * destination , const char * source , size_t num );

注意事项：

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

函数模拟

char* my_strncpy(char* start, const char* source,size_t num)
{
	char* start1 = start;
	if (num > strlen(source))
	{
		while (*start++ = *source++);
		for (int i = 0; i < num- strlen(source)-1; i++)
			*(start + i) = 0;
		return start1;
	}
	else
	{
		for (int i = 0; i < num; i++)
			*(start + i) = *(source + i);
		return start1;
	}
}

1.6 strncat

函数原型： char * strncat ( char * destination , const char * source , size_t num );

注意事项：

• 如果源字符串的长度小于num，则链接完源字符串之后，在目标的后边追加一个0。
• 如果源字符串的长度大于于num，则链接完源字符串之后，会在目标的后边追加一个0。

1.7 strncmp

函数原型：int strncmp ( const char * str1, const char * str2, size_t num );

注意事项：

 来源：http://cpluscplus.com 

• 返回的值在不同编译器上不同（与strcmp函数一样）但具体规则如上图。
• 与strcmp函数基本类似，不同的地方在于strncmp指定了比较范围。

字符查找函数

1.8 strstr

在str1字符串中寻找子字符串str2，找到了则返回位置。未找到或移到末尾则返回空指针。

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

注意事项：

• 如果想在第一次寻找的位置继续向后寻找时，第一个参数只需要传 NULL 。

1.9 strtok

在str字符串中寻找sep字符集中存在的标记替换成'\0'并返回当前地址。

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

注意事项：

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

• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改。）
• strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
• strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。
• 如果字符串中不存在更多的标记，则返回 NULL 指针。

错误信息报告函数

1.10 strerror

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

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

字符操作函数

这类函数还有很多感兴趣的小伙伴可自行查找学习。

内存操作函数

1.11 memcpy

将source位置处num个字节复制到destination处。

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

注意事项：

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 '\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。

函数模拟

void * memcpy ( void * dst, const void * src, size_t count)
{
        void * ret = dst;
 assert(dst);
   assert(src);
        /*
         * copy from lower addresses to higher addresses
         */
        while (count--) {
                *(char *)dst = *(char *)src;
                dst = (char *)dst + 1;
                src = (char *)src + 1;
       }
        return(ret);
}

1.12 memmove

将指定位置和指定长度拷贝到目标的地址。

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

注意事项：

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

函数模拟：

void * memmove ( void * dst, const void * src, size_t count)
{
        void * ret = dst;
        if (dst <= src || (char *)dst >= ((char *)src + count)) 
        {
                /*
                 * Non-Overlapping Buffers
                 * copy from lower addresses to higher addresses
                 */
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
               }
       }
        else {
                /*
                 * Overlapping Buffers
                 * copy from higher addresses to lower addresses
                 */
                dst = (char *)dst + count - 1;
                src = (char *)src + count - 1;
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst - 1;
                        src = (char *)src - 1;
               }
       }
        return(ret);
}

1.13 memcmp

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

int memcmp ( const void * ptr1   ,    const void * ptr2   ,    size_t num  );

返回值如下：

数据来源： https://legacy.cplusplus.com/reference/cstring/memcmp/?kw=memcmp

以上就是今天带来的内容！