字符串与内存函数及其模拟实现

ImpEvday_Wang

已于 2022-09-02 23:34:17 修改

阅读量152

点赞数

文章标签： c++ 开发语言 c语言

于 2022-09-01 11:26:00 首次发布

本文链接：https://blog.csdn.net/Hhhh_Jy/article/details/126623887

版权

strlen函数

头文件 string.h

函数原型

size_t strlen ( const char* str ) ;

函数用法

strlen是用于求字符串长度的函数，strlen函数会从所给地址向后找'\0'，直到找到为止，找到第一个'\0'就返回，返回值是'\0'之前字符的个数

#include<stdio.h>
#include<string.h>
int main()
{
	
	char arr1[] = "abcdef";
	//a b c d e f \0

	char arr2[] = { 'a','b','c','d','e','f' };
	//a b c d e f

	char arr3[] = { 'a','b','c','d','e','f','\0' };
	//a b c d e f \0

	char arr4[10] = { 'a','b','c','d','e','f' };
	//a b c d e f \0 \0 \0 \0，不完全初始化时，编译器会将未初始化的空间自动初始化为0

	int len1 = strlen(arr1);	//6
	int len2 = strlen(arr2);	//随机值
	int len3 = strlen(arr3);	//6
	int len4 = strlen(arr4);	//6

	return 0;

注意：函数的返回值为size_t，是无符号的

#include<stdio.h>
#include<string.h>

int main()
{

	//此时输出的是 > 
	//因为strlen返回的是无符号数，strlen("abc")返回3，strlen("abcdef")返回6
	//3-6= -3，但两个无符号数相减得到的也是一个无符号数
	//因此内存中-3的补码被的符号位将被看作数据位，因此是一个很大的正数，一定>0
	if (strlen("abc") - strlen("abcdef") > 0)
	{
		printf(">\n");
	}
	else
	{
		printf("<\n");
	}

	//可以将条件判断语句改为如下
	//1.strlen("abc") > strlen("abcdef")
	
	//2.(int)strlen("abc") - (int)strlen("abcdef") > 0

	//均可以得到正确结果

	return 0;
}

模拟实现

1.用计数器实现

size_t my_strlen(const char* p)
{
	size_t count = 0;

	//每次进入循环后指针指向下一位
	while (*p++)
	{
		count++;
	}
	return count;
}

2.递归实现

size_t my_strlen(const char* p)
{
	if (*p == '\0')
	{
		return 0;
	}
	else
	{
		return 1 + my_strlen(p + 1);
	}
}

3.指针-指针实现

size_t my_strlen(const char* p)
{ 
	const char* s = p;
	while(*p)
	{
		p++;
	}
	return p - s;
}

测试

int main()
{
	char arr[] = "abcdef";

	int len = my_strlen(arr);

	printf("%d\n", len);
	return 0;
}

strcpy函数

函数原型

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

函数用法

字符串拷贝函数，将源字符串拷贝到目标地址，返回值是目标空间的起始地址，源字符串的'\0'也一起拷贝到目标地址

#include<stdio.h>
#include<string.h>

int main()
{
	//此空间必须足够大，以确保能存放下原字符串
	char arr1[20] = { 0 };

	char* arr2 = "impwang";

	char arr3[] = "abcdef";
	//a b c d e f \0

	//将arr3的字符串拷贝到arr2里，程序会崩溃
	//因为arr2指向的是常量字符串，常量不可修改
	strcpy(arr2, arr3);
	printf("%s", arr2);

	char arr4[] = { 'a','b','c','d','e','f' };  //拷贝err
	//a b c d e f

	char arr5[] = { 'a','b','c','d','e','f','\0' };
	//a b c d e f \0

	char arr6[10] = { 'a','b','c','d','e','f' };
	//a b c d e f \0 \0 \0 \0

	//将arr3字符串拷贝到arr1里，arr3的'\0'也一起拷贝到arr1里
	//源字符串必须要有'\0'
	strcpy(arr1, arr3);

	printf("%s\n", arr1);
	return 0;
}

模拟实现

char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);

	char* ret = dest;
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

测试

int main()
{
	char arr1[20] = { 0 };
	char* arr2 = "ImpEvday Wang";

	printf("%s", my_strcpy(arr1, arr2));
	return 0;
}

strcat函数

函数原型

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

函数用法

字符串追加函数，将源字符串追加到目标空间，从目标空间的第一个'\0'位置开始追加，源字符串和目标空间必须都有'\0'，目标空间要足够大并且可以被修改，源字符串的'\0'也要追加进去

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[20] = "ImpEvday";

	//从第一个'\0'的位置开始追加
	char arr2[20] = { 'I','m','p','\0','d','a','y','\0' };

	//目标空间没有'\0'且不够大
	char arr3[] = { 'a','b','c','d','e','f' };

	char arr4[] = "Wang";

	strcat(arr1, arr4);

	strcat(arr2, arr4); 

	strcat(arr3, arr4);

	printf("%s\n", arr1);	//ImpEvdayWang
	printf("%s\n", arr2);	//ImpWang
	printf("%s\n", arr3);	//err

	return 0;
}

模拟实现

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);

	char* ret = dest;

	//找目标空间'\0'
	while (*dest)
	{
		dest++;
	}

	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

测试

int main()
{
	char arr1[20] = "ImpEvday";
	char arr2[] = "Wang";

	printf("%s", my_strcat(arr1, arr2));

	return 0;
}

strcmp函数

函数原型

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

函数用法

比较字符串中对应位置上的字符的大小(ASCII码值)，如果相同，就比较下一对，直到遇到一对不同或者遇到'\0'结束

当str1>str2，返回值大于0；

当str1 = str2，返回值等于0；

当str1<str2，返回值小于0

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcde";
	char arr2[] = "abcf";

	int ret = strcmp(arr1, arr2);

	if (ret > 0)
	{
		printf(">\n");
	}
	else if (ret == 0)
	{
		printf("=\n");
	}
	else
	{
		printf("<\n");
	}

	return 0;
}

模拟实现

int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);

	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			//相等
			return 0;
		}
		s1++;
		s2++;
	}

	//不相等
	if (*s1 > *s2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}

测试

int main()
{
	char arr1[] = "abcde";
	char arr2[] = "abcf";

	int ret = my_strcmp(arr1, arr2);

	if (ret > 0)
	{
		printf(">\n");
	}
	else if (ret == 0)
	{
		printf("=\n");
	}
	else
	{
		printf("<\n");
	}
	return 0;
}

strncpy函数

函数原型

char * strncpy ( char * destination, const char * source, size_t num );

函数用法

num是需要拷贝的字符个数

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "xxxxx";
	char arr2[] = "ImpEvday";

	char arr3[] = "Ev";

	//当源字符串的字符个数小于num，拷贝到目标空间后向后补缺少个数个'\0'
	printf("%s\n", strncpy(arr1, arr3, 4));	//Ev

	printf("%s\n", strncpy(arr1, arr2, 3));	//Imp

	return 0;
}

模拟实现

#include<stdio.h>
#include<assert.h>

char* my_strncpy(char* dest, const char* src, size_t n)
{
    assert(dest && src);

    int i;
    for (i = 0; src[i] && i < n; i++)
    {
        dest[i] = src[i];
    }

    if (i < n)
    {
        dest[i] = 0;
    }
    return dest;
}

测试

strncat函数

函数原型

char * strncat ( char * destination, const char * source, size_t num );

函数用法

num是需要追加的字符个数，当源字符串长度大于num时，将源字符串中的num个字符追加到目标空间后，会自动在目标空间补上一个'\0'，当源字符串长度小于num时，只把源字符串的所有字符追加到目标空间，不额外补充'\0'

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[20] = "ImpEvday";
	char arr2[] = "Wangxxx";

	printf("%s", strncat(arr1, arr2, 4));	//ImpEvdayWang
	return 0;
}

模拟实现

char* my_strncat(char* dest, const char* src, size_t n)
{
    assert(dest && src);

    char* tmp = dest;

    while (*dest)
    {
        dest++;
    }

    int i;
    for (i = 0; src[i] && i < n; i++)
    {
        dest[i] = src[i];
    }

    dest[i] = 0;
    return tmp;
}

测试

int main()
{
    char arr1[20] = "ImpEvday";
    char arr2[] = "Wang";

    printf("%s", my_strncat(arr1, arr2, 2));

    return 0;
}

strncmp函数

函数原型

int strncmp ( const char * str1, const char * str2, size_t num );

函数用法

num表示比较到第几对字符，如果还没比较到num就有不相等的情况，就直接停止比较

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "abcde";
	char arr2[] = "abcf";

	int ret = strncmp(arr1, arr2, 4);

	return 0;
}

strstr函数

函数原型

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

函数用法

看str2字符串是否是str1字符串的子串，如果str2字符串在str1字符串中出现，就返回str2在str1中第一次出现的地址，如果没出现(找不到)，就返回NULL

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "cde";

	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("不是\n");
	}
	else
	{
		printf("是\n");
	}
	return 0;
}

模拟实现

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);

	const char* s1 = str1;
	const char* s2 = str2;

	//记录此次查找的起始位置
	const char* cur = str1;

	while (*cur)
	{
		s1 = cur;
		s2 = str2;
		//s1，s2相等且不能为'\0'
		while (*s1 && *s2 && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		//找到子串
		if (*s2 == '\0')
		{
			return (char*)cur;
		}
		cur++;
	}
	//找不到
	return NULL;
}

测试

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "cde";

	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到子串\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

strtok函数

函数原型

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

函数用法

delimiters字符串是分隔符的字符集合，str字符串中可能包含0个或多个被delimiters集合中的分隔符分隔开的标记，strtok函数会找到str中的下一个标记，将分隔符改为'\0'，并返回一个指向这个标记的指针

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "@Imp@Evday_Wang";

	char del[] = "@_";

	//这次strtok函数后，arr在内存中的存储为
	//@ I m p \0 E v d a y _ W a n g \0
	//返回的指针为字符'I'所对应的地址
	printf("%s\n", strtok(arr1, del));	//Imp
	printf("%s\n", arr1);				//@Imp

	//由于strtok函数会改变被操作的字符串，因此使用strtok函数切分的字符串一般都是临时拷贝的

	char arr2[] = "He_llo";
	char arr3[20] = { 0 };

	strcpy(arr3, arr2);

	//strtok调用完成后并没有对arr2进行操作，arr2字符串不变
	printf("%s\n", strtok(arr3, del));	//He
	printf("%s\n", arr2);				//He_llo

	return 0;
}

如果strtok第一个参数不为NULL，函数找到str第一个标记，并将保存分隔符在当前字符串中的位置

如果strtok第一个参数为NULL，函数从被保存的位置开始，查找下一个标记

当字符串中找不到下一个标记，就返回NULL

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "@Imp@Evday_Wang";
	char arr2[30] = { 0 };

	strcpy(arr2, arr1);
	
	char del[] = "@_";

	//找到第一个标记，保存这个标记后的分隔符位置
	printf("%s\n", strtok(arr1, del));	//Imp

	//从上一个保存好的位置向后继续查找
	printf("%s\n", strtok(NULL, del));	//Evday
	printf("%s\n", strtok(NULL, del));	//Wang

	//找不到更多标记了，返回NULL
	printf("%s\n", strtok(NULL, del));	//(null)

	//循环strtok
	char* str = NULL;
	for (str = strtok(arr2, del); str != NULL; str = strtok(NULL, del))
	{
		printf("%s\n",str);
	}

	return 0;
}

strerror函数

函数原型

char * strerror ( int errnum );

函数用法

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

当某一个库函数调用失败，会留下一个错误码(全局变量:errno)，strerror会返回这个错误码所对应的错误信息

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<limits.h>

int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	printf("%s\n", strerror(4));

	//动态开辟内存
	int* p = (int*)malloc(LLONG_MAX);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));

		//perror参数是一个字符串，打印出参数:错误信息
		perror("malloc");
		return 1;
	}
	return 0;
}

memcpy函数

函数原型

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

函数用法

将源字符串从source地址处向后的num个字节的元素拷贝到目标空间中(不能实现重叠内存拷贝）

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[5] = { 0 };

	char arr3[] = "abcde";
	char arr4[5] = "efgh";

	memcpy(arr2, arr1, 20);
	//将arr1中前5个整型元素拷贝到arr2中

	memcpy(arr4, arr3, 5);	
	
	printf("%s\n", arr4);	
	//abcde随机值 - 因为将arr3的五个字节拷贝到arr4里，arr4最后没有'\0'
	
	return 0;
}

模拟实现

void* my_memcpy(void* dest, const void* src, size_t count)
{
	assert(dest && src);

	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

测试

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[5] = { 0 };

	my_memcpy(arr2, arr1, 20);

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

memmove函数

函数原型

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

函数用法

将源字符串从source地址处向后的num个字节的元素拷贝到目标空间中(可以实现重叠内存拷贝）

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };

	//将从arr1开始向后五个元素拷贝到arr1+2位置开始向后的五个位置
	memmove(arr1 + 2, arr1, 20);

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	//输出 1 2 1 2 3 4 5 8 9 10
	return 0;
}

模拟实现

void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);

	void* ret = dest;

	if (dest < src)
	{
		//从前向后拷贝
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//从后向前拷贝
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return ret;
}

测试1

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };

	my_memmove(arr1 + 2, arr1, 20);

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

测试2

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };

	my_memmove(arr1, arr1 + 2, 20);

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

memcmp函数

函数原型

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

函数用法

按字节进行比较大小

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcde";
	char arr2[] = "abcmn";

	//int ret = memcmp(arr1, arr2, 3);	//前3个字节相等，输出 =
	int ret = memcmp(arr1, arr2, 4);	//第4个字节不相等，输出<

	if (ret > 0)
	{
		printf(">\n");
	}
	else if (ret == 0)
	{
		printf("=\n");
	}
	else
	{
		printf("<\n");
	}
	return 0;
}

memset函数

函数原型

void * memset ( void * ptr, int value, size_t num );

函数用法

内存设置函数，将ptr地址开始向后数num个字节都设置为value（将每个字节都设置为value）

#include<stdio.h>
#include<string.h>
int main()
{
	int arr[6] = { 0,1,2,3,4,5 };

	//将前12个字节都设置为0
	memset(arr, 0, 12);

	int i = 0;
	for (i = 0; i < 6; i++)
	{
		printf("%d ", arr[i]);
	}
	//输出 0 0 0 3 4 5
	return 0;
}

字符分类函数

头文件：ctype.h

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