[C++知识库]C语言的字符串函数与内存函数的功能与模拟实现

字符串与内存函数

1.1 strlen 字符串长度

size_t strlen(const char* str);

??有的编译器用int接受strlen的返回值会报错，因为size_t是无符号整形。

size_t sz=strlen(arr);
printf("%u",arr);

• str指向的字符串必须包含’\0’，否则无法计算字符串长度。
• -strlen函数返回无符号整形的问题：

int main()
{
    if(strlen("abc")-strlen("abcedf")>0)
    {
        printf("hehe\n");
    }
    else
    {
        printf("haha\n");
    }
    //由于strlen函数返回的是无符号整形，所以3-6=-3但是会被理解成一个无符号整形数，所以还是大于0。
    return 0;
}

strlen的三种模拟实现

1. 递归(不需要临时变量求字符串长度)
size_t mystrlen(const char* arr)
{
    assert(arr);
	if (*arr == '\0')
	{
		return 0;
	}
	else
	{
		arr++;
		return 1 + mystrlen(arr);
	}
}

2.地址相减
size_t mystrlen(const char* arr)
{
    assert(arr);
	char* p = arr;
	while (*arr != '\0')
	{
		arr++;
	}
	return arr - p;

}

3.计数器
    
size_t mystrlen(const char* arr)
{
    assert(arr);
	int count = 0;
	while (*arr != '\0')
	{
		count++;
		arr++;
	}
	return count;
}

1.2 strcpy 字符串拷贝

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

• 把source指向的字符串拷贝到destination所指向的空间，并且返回指向这个空间首元素地址。

• 源字符串必须以 ‘\0’ 结束。 会将源字符串中的 ‘\0’ 拷贝到目标空间。

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

• 目标空间必须可变。const char* p=“xxxxxxx”;

• 这个函数不安全，不管是否越界访问内存就硬拷。

• strcpy实现

char* mystrcpy(char* des, const char* source)
{
    assert(des && source);
	char* p = des;
	while (*des++ = *source++;)
        //当*source='\0'的时候 表达式值为\0，
        //而\0的ASCII码值是0会停下while循环。
	{
		;
	}
	return p;
}

1.3 strcat 字符串链接

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

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

strcat模拟实现

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

1.4 strcmp 字符串比较

比较的大小是字符串的内容(对应字符的ASCII码值大小)，而不是字符串的长度。

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

标准规定：

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

int mystrcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			return 0;//说明到尾了且这俩相等。
		}
		s1++;
		s2++;
	}
	return *s1 - *s2;
}

以上3个函数都是长度不受限制的字符串函数，可能会出现越界访问内存，不够安全。

因此有strncpy strncat strncmp这三种长度受限制的字符串函数，相对安全。

1.5 strncpy

char * strncpy ( char * destination, const char * source, size_t num );
//num拷贝字符的个数。

• 拷贝num个字符从源字符串到目标空间。

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

strncpy模拟实现

char* mystrncpy(char* des, const char* src, size_t num)
{
	assert(des && src);
	int sz = strlen(src);
	char* p = des;
	if (num <= sz)
	{
		for (int i = 0; i < num; i++)
		{
			des[i] = src[i];
		}
		return p;
	}
	else
	{
		for (int i = 0; i < sz; i++)
		{
			des[i] = src[i];
		}
		for (int j = sz; j < num; j++)
		{
			des[j] = '\0';
		}
		return p;
	}
}

1.6 strncat

char * strncat ( char * destination, const char * source, size_t num );
//num 追加的字符数。

• 追加的时候是先找到第一个\0然后替换上第一个字符，依次追加后续字符，最后补一个\0，所以住过要追加num个字符后面至少还得有num+1个位置。
• 如果追加字符串长度小于num，那么它只会追加追加字符串长度个字符。
  strncat模拟实现

char* mystrncat(char* des, const char* src, size_t num)
{
	assert(des && src);
	int len = strlen(src);
	char* p = des;
	while (*des != '\0')
	{
		des++;
	}
	if (num <= len)
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			des[i] = src[i];
		}
		des[num] = '\0';
	}
	else
	{
		while (*des++ = *src++);
	}
	return p;
}

1.7 strncmp

int strncmp ( const char * str1, const char * str2, size_t num );
//num比较的字符串个数

比较两个字符串的前num个字符。
strncmp模拟实现

int mystrncmp(const char* s1, const char* s2, size_t num)
{
	assert(s1 && s2);
	int count = 0;
	while (count < num && *s1 == *s2)
	{
		if (*s1 =='\0')
		{
			return 0;
		}
		s1++;
		s2++;
		count++;
	}
	return *s1 - *s2;
}

1.8 strstr 字符串查找函数

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

返回一个指针指向str2在str1第一次出现的首字母地址，若没有出现则返回NULL。
strstr模拟实现

char* mystrstr(const char* str1, const char* str2)
{
	//思路 用str1保存串1首元素地址 用str2保存串2的首元素地址
	//cp表示从str1串的哪个位置开始比较
	//s1是串1用来比较时的指针
	//s2是串2用来比较时的指针
	char* cp = str1;
	char* s1 = str1;
	char* s2 = str2;
	if (*s2 == '\0')//如果是空字符，直接返回就好了。
	{
		return str1;
	}
	while (*cp != '\0')//还没走到尾比较还没结束
	{
		s1 = cp;
		s2 = str2;
		//while (*s1!='\0' && *s2!='\0' && *s1 == *s2)
		while (*s1 && *s2 && *s1 == *s2)
		//比较有三种可能跳出循环，
		//如果s1s2前面一直相等，s2走到尾巴了==\0，这说明匹配成功,跳出；
	    //如果s1和s2前面一直相等，但是s1走到尾巴了s2还没走到尾巴，也不能够再匹配了跳出；
		//如果不相等了，也跳出
		//我们要控制他们不要比到\0的情况，要不然可能会越界访问。
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		//只有这种是匹配成功的情况
		{
			return cp;
		}
		cp++;
	}
	return NULL;//如果一次返回都没有走到这里了，说明寻找失败了
}
//以上为BF算法，库里也是这么实现的

在字符串查找中，有一个算法叫KMP算法。

1.9 strtok 字符串分割函数

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

• sep参数是一个字符串，它是分割符的集合，比如2587966900@qq.com，想割出2587966900和qq和com,seq这个参数就得等于"@.".
• 关于第一个参数str，其用法是
• 第一次传非空指针str，当第一个参数不是NULL时，会找到字符串str中的第一个标记，并且会将这个标记符改为\0，然后strtok函数会记住这个位置(这个记忆的特性说明strtok函数内部使用了静态变量或者全局变量)，并且返回一个指向首元素的指针。
• 后续调用都传空指针，当第一个参数是NULL时，strtok函数将从第一个被保存的位置开始往后找标记符，找到后更新保存位置，返回一个指向被保存的位置的后一个位置的指针。
• 当字符串中不存在更多的标记时，strtok函数会返回NULL;

基于strtok函数的特性，我们可以这样设计程序：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "2587966900@qq.com";
	char arr1[100] = { 0 };
	strcpy(arr1, arr);
	char* cunfang[3] = { 0 };
	char* ret = NULL;
	char seq[] = "@.";
	int i = 0;
	for (ret = strtok(arr1, seq); ret != NULL; ret = strtok(NULL, seq))
	{
		cunfang[i] = ret;
		i++;
	}
	for (int j = 0; j < 3; j++)
	{
		printf("%s\n", cunfang[j]);
	}
	return 0;
}

1.10 strerror 错误信息报告函数

char * strerror ( int errnum );

必须包含的头文件<string.h> <errno.h>

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

C语言库函数调用失败的时候，会把错误码存储到errno变量中。

还有个更直接的库函数perror，等价于打印错误码对应的错误信息。

#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
        perror("测试")；
       //就会输出测试: 错误信息。
		return -1;
	}
	else
	{
		printf("打开成功");
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

1.11 memcpy 不重复情况下的内存拷贝

void * memcpy ( void * destination, const void * source, size_t num );
//num 拷贝的字节数
//可以直接以内存的方式拷贝，不止拷贝字符串，整型，结构体，数组等等都可以。

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。
• 如果有重叠的拷贝，考虑memmove函数。

//模拟实现


//思路1 for循环
void* mymemcpy(void* des,const void* src, size_t num)
{
	assert(des && src);
	char* p1 = (char*)des;
	char* p2 = (char*)src;
	for (int i = 0; i < num; i++)
	{
		p1[i] = p2[i];
	}
	return des;
}

//思路2 while循环
void* mymemcpy(void* des, const void* src, size_t num)
{
	assert(des && src);
	void* p = des;
	while (num--)
	{
		*(char*)des = *(char*)src;
		des = (char*)des + 1;
		src = (char*)src + 1;
	}
	return p;
}

虽然vs环境下memcpy也能实现内存重叠情况下的拷贝，但是C语言标准中对memcpy函数的要求仅仅是完成内存不重叠情况下的拷贝，你不要知网memcpy能完成内存重叠情况下的拷贝。

1.12 memmove 可以处理重复情况下的内存拷贝

void * memmove ( void * destination, const void * source, size_t num );

作用：可以实现内存重复情况下的内存拷贝

//实现思路1:利用动态内存分配

void* mymemmove(void* des, const void* src, size_t num)
{
	assert(des && src);
	char* p1 = (char*)des;
	char* p2 = (char*)src;
	char* p = (char*)malloc(num);
	for (int i = 0; i < num; i++)
	{
		p[i] = p2[i];
	}
	for (int i = 0; i < num; i++)
	{
		p1[i] = p[i];
	}
	free(p);
	p = NULL;
	return des;
}

//不用动态内存分配的实现思路：发现如果des在src的前面，那么就从前往后拷贝不会出现问题；如果des在src的后面，那么从后向前拷贝就可以了

void* my_memmove(void* des, const void* src, size_t count)
{
	void* p = des;
	if (des < src)
	{
		while (count--)
		{
			*(char*)des = *(char*)src;
			des = (char*)des + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (count--)
		{
			*((char*)des + count) = *((char*)src + count);
            //count进来就已经减1了，des强转为char*后加count正好是最后一个元素地址，同理src。
		}
	}
	return p;
}

1.13 memcmp 内存比较

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

• 比较两块内存的前num个字节，如果都相等返回0；
• 否则对比第一个不相等的两个字节，
• 如果ptr1的小，则返回一个小于0的数，
• 如果ptr2的小，则返回一个大于0的数。

memcpy模拟实现

int mymemcmp(const void* s1, const void* s2, size_t num)
{
	char* p1 = (char*)s1;
	char* p2 = (char*)s2;
	int i = 0;
	while (*p1 == *p2 && i<num)
	{
		p1++;
		p2++;
		i++;
	}
	if (i == num)
	{
		return 0;
	}
	else
	{
		return *p1 - *p2;
	}
}

1.14 memset 内存设置

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

把目标空间的count的字节都设置成一个数a，这个数a是一个0~255范围内的unsigned char，是对int c进行截断得到的，返回目标空间起始地址。

一般用在初始化一些结构体之类的。
memset模拟实现

void* mymemset(void* dest, int c, size_t num)
{
	char* p = (char*)dest;
	size_t b = (size_t)c;
	for (int i = 0; i < num; i++)
	{
		p[i] = b;
	}
	return dest;
}