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

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> C语言的字符串函数与内存函数的功能与模拟实现 -> 正文阅读

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