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

-> C++知识库 -> 深入理解＜string.h＞库和内存函数（字符题目神器） -> 正文阅读

[C++知识库]深入理解＜string.h＞库和内存函数（字符题目神器）

＜string.h＞库

????????一、strlen（）

????????二、strcpy（）

????????---strncpy（）

????????三、strcat（）

?????????---strncat（）

????????四、strcmp（）

????????---strncmp（）?

＜string.h＞库

一、strlen（）

size_t strlen(const char * str);

字符串会以‘\0’作为结束标志，strlen则会返回’\0’以前出现的字符个（不包含\0）若没有‘\0’，则会出现找不到\0返回随机值的情况。

strlen（）的模拟实现：

unsigned int my_strlen(char* p)
{
	int count = 0;
	while (*p++)
	{
		count++;
	}
	return count;
}

易错点：

#include<stdio.h>
#include<string.h>
int main()
{
	//if ((int)strlen("abc") - (int)strlen("abcdef") > 0)
	if (strlen("abc") - strlen("abcdef")>0 )
		printf(">");
	else
		printf("<=");
	
	return 0;
}

这个会打印什么呢？

答案：

-3 > 0吗？！！

原来，size_t strlen(const char * str);中的size_t表示unsigned int（无符号整形）即：size_t strlen(const char * str);--->unsigned int?strlen(const char * str);

#include<stdio.h>
#include<string.h>
int main()
{

	if ((int)strlen("abc") - (int)strlen("abcdef") > 0)
	//if (strlen("abc") - strlen("abcdef")>0 )
		printf(">");
	else
		printf("<=");
	printf("\n");
	printf("%u\n", strlen("abc") - strlen("abcdef"));//很大的正数 
	printf("%d\n", (int)strlen("abc") - (int)strlen("abcdef"));//-3
	//	然而
	printf("%d\n", strlen("abc") - strlen("abcdef"));//-3
	return 0;
}

?经过测试可知，两个无符号整形相减只能是正数，但是打印时不注意%u和%d容易误解；

所以判断比较strlen的长度时要用：

if ((int)strlen("abc") - (int)strlen("abcdef") > 0)
if (strlen("abc") > strlen("abcdef") )
不可
if (strlen("abc") - strlen("abcdef") > 0)

这是由strlen类型导致的易错点！

二、strcpy（）

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

strcpy（）模拟实现：

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

源字符串即待拷贝字符串，必须以’\0‘结束
会将源字符串中的’\0’拷贝到目标字符串
目标空间需要足够大，来确保能够存放源字符串.
目标空间必须可变

?测试：

1.将’\0‘去除

2.编译器内存框观察是否会将源字符串中的’\0’拷贝到目标字符串

3.将N改为小于字符串abcdef长度的数，如5

4.在char* dest前也加const，使目标空间必须不可变

#include<stdio.h>
#include<string.h>
const int N = 20;
char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[] = {'a', 'b', 'c', 'd', 'e', 'f', '\0'};
	char arr2[N] = "xxxxxxxxxxxx";
	my_strcpy(arr2, arr1);
	//strcpy(arr2, arr1);
	printf("%s\n", arr2);
	printf("%s\n", my_strcpy(arr2, arr1));
    //printf("%s\n", strcpy(arr2, arr1));
	return 0;
}

?测试结束后你将彻底掌握strcpy（）；

---strncpy（）

char * strncpy(char * dest, const char * sour, size_t num);

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

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "123456789";
	char arr2[] = "abcdefg";
	printf("%s\n", arr1);
	strncpy(arr1a, arr2, 5);
	printf("%s\n", arr1);

	return 0;
}


output 123456789
       abcde6789

三、strcat（）

char * strcat ( char * dest, const char * sour);

strcat（）?模拟实现：

char* my_strcat(char* arr, const char* arr1)
{
	char* ret = arr;
	assert(arr && arr1);
	while (*arr)
	{
		arr++;
	}
	while ((*arr++ = *arr1++))
	{
		;
	}
	return ret;
}

源字符串必须以’\0’为结束。
目标空间足够大。
目标空间可修改.
注意不可字符串自己给自己追加，会出现目标空间不足的情况

可粗略理解为两个字符串拼接在一起?

#include<stdio.h>
#include<string.h>
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	//1. 目标空间中的\0
	while (*dest)
	{
		dest++;
	}
	//2. 追加内容到目标空间
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";// {'w', 'o', 'r', 'l', 'd', '\0'};

	printf("%s\n", my_strcat(arr1, arr2));
	printf("%s\n", arr1);
	//printf("%s\n", strcat(arr1, arr2));

	return 0;
}

?---strncat（）

char * strncat( char * dest, const char * sour, size_t num);

同理，遇到\0停止?

#include<stdio.h>
#include<string.h>
const int N=10;
int main()
{
	char arr1[20] = "12345\0xxxxxxx";
	char arr2[] = "abcdefg\0yyy";
	printf("%s\n", arr1);
	strncat(arr1, arr2, N);
	//strncpy(arr1, arr2, 5);
	printf("%s\n", arr1);
	return 0;
}


output 12345
       12345abcdefg

若N=2
output 12345
       12345ab

四、strcmp（）

int strcmp ( const char * str1, const char * str 2);

?strcmp（）模拟实现：


#include<stdio.h>
#include<string.h>
int my_strcmp(const char* str1, const char*str2)
{
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		
		str1++;
		str2++;
	}
	return *str1 - *str2;

第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，返回小于0的数字
字符串比较时，对应位置一一比较

测试：?

#include<stdio.h>
#include<string.h>
int my_strcmp(const char* str1, const char*str2)
{
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		
		str1++;
		str2++;
	}
	return *str1 - *str2;

	/*if (*str1 > *str2)
		return 1;
	else
		return -1;*/
}
int main()
{
	//strcmp - 字符串比较
	//比较是对应位置上的字符大小
	char arr1[] = "abd";
	char arr2[] = "abce";

	int ret = my_strcmp(arr1, arr2);

	if (ret<0)
	{
		printf("arr1<arr2");
	}
	else if (ret >0)
	{
		printf("arr1>arr2");
	}
	else
	{
		printf("arr1==arr2");
	}

	return 0;
}

---strncmp（）?

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

比较出现不一样的字符
一个字符串结束
num个字符全部比完

#include<stdio.h>
#include<string.h>
const int N = 3;
int main()
{
	
	char arr1[] = "abcwef";
	char arr2[] = "abcqqqqqq";
	int ret = strncmp(arr1, arr2, N);
	if (ret < 0)
	{
		printf("arr1<arr2");
	}
	else if (ret > 0)
	{
		printf("arr1>arr2");
	}
	else
	{
		printf("arr1==arr2");
	}
	return 0;
}

output arr1==arr2

五、strstr（）

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

?strstr（）模拟实现：?

char* my_strstr(const char* str, const char* substr)
{
	const char* s1 = str;
	const char* s2 = substr;
	const char* cur = str;


	if (*substr == '\0')
	{
		return (char*)str;
	}
	while (*cur)
	{
		s1 = cur;
		s2 = substr;
		while (*s1 &&  *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)cur;

		cur++;
	}
	return NULL;
}

寻找子集，看str1中是否存在str2.
若存在，返回str1中出现str2的地址
若不存在，返回NULL

?测试：

#include<stdio.h>
#include<string.h>
char* my_strstr(const char* str, const char* substr)
{
	const char* s1 = str;
	const char* s2 = substr;
	const char* cur = str;


	if (*substr == '\0')
	{
		return (char*)str;
	}
	while (*cur)
	{
		s1 = cur;
		s2 = substr;
		while (*s1 &&  *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)cur;

		cur++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";

	char* ret = my_strstr(arr1, arr2);
    //char* ret = strstr(arr1, arr2);

	if (NULL == ret)
		printf("没找到\n");
	else
		printf("%s\n", ret);

	return 0;
}

output：?

bbcdef

六、strtok（）?

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

??strtok（）模拟实现：?

char * strstr (const char * str1, const char * str2)
{
char *cp = (char *) str1;
char *s1, *s2;
if ( !*str2 )
return((char *)str1);
while (*cp)
{
s1 = cp;
s2 = (char *) str2;
while ( *s1 && *s2 && !(*s1-*s2) )
s1++, s2++;
if (!*s2)
return(cp);
cp++;
}
return(NULL);

sep参数是个字符串，定义了用作分隔符的字符集合

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

strtok函数找到str中的下一个标记，并将其用\0结尾，返回─个指向这个标记的指针。(注:strtok函数会改变被操作的字符串，
所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。)

strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回NULL指针。
?

1. strtok函数找第一个标记的时候，函数的第一个参数丕是NULD.
2. strtok函数找非第一个标记的时候，函数的第一个参数是NULL

例子：

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

int main()
{
	const char* p = "@.#";
	char arr[] = "zpengwei@yeah.net#hehe";
	char buf[50] = { 0 };// "zpengwei@yeah.net"
	strcpy(buf, arr);

	char* str = strtok(buf, p);//zpengwei
	printf("%s\n", str);
	str = strtok(NULL, p);//yeah
	printf("%s\n", str);
	str = strtok(NULL, p);//net
	printf("%s\n", str);
	//strtok - 开始返回NULL

	return 0;
}



output zpengwei
       yeah
       net

标准用法：

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

int main()
{
	const char* p = "@.#";
	char arr[] = "zpengwei@yeah.net@hehe#666";
	char buf[50] = { 0 };
	strcpy(buf, arr);
	char* str = NULL;

	for (str = strtok(buf, p); str != NULL; str=strtok(NULL, p))
	{
		printf("%s\n", str);
	}
	return 0;
}

?测试输出：

七、字符分类函数

使用前先引#include <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	任何可打印字符，包括图形字符和空白字符

实用例子：

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

output test string.

内存函数

?一、memcpy（）

void * memcpy( void * dest, const void * sour, size_t num)

memcpy（）模拟实现：?

void* my_memcpy(void* dest, const void*src, size_t num)
{
	void* ret = dest;

	while (num--) 
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}

	return ret;
}

函数从sour的位置开始向后复制num个字节数据到dest的内存位置
遇到’\0’并不会停下来
不管有任何重叠，复制的结果是未定义的

?测试：

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

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

	memcpy(arr4, arr3+5, 5*sizeof(arr3[0]));

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

	return 0;
}

output 6 7 8 9 10

二、memmove（）?

void * memmove ( void * dest, const void * sour, size_t num);

?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;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		while (num--)
		{
			*((char*)dest+num) = *((char*)src + num);
		}
	}
	return ret;
}

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

?测试：

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

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

void test1()
{
	int arr3[] = { 1,2,3,4,5,6,7,8,9,10 };
	//1 2 1 2 3 4 5 8 9 10
	//my_memcpy(arr3+2, arr3, 5 * sizeof(arr3[0]));
	//my_memmove(arr3, arr3+2, 20);
	memmove(arr3+2, arr3, 20);

	//memcpy(arr3+2, arr3, 20);

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

	return 0;
}

总结：memmove （A,B,元素个数*元素字节）用法---->将从B数组地址表示的元素开始，向后包含（元素个数*元素字节）个字节表示的元素，覆盖从A数组地址表示的元素开始个元素。

三、memcmp（）

void * memmcp ( void * dest, const void * sour, size_t num);

#include<stdio.h>
#include<string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 'a','b',1,2,3 };
	int ret = memcmp(arr1, arr2+2, 9);

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


output 0

非常简单的比较

A=B return 0；

A>B return 1；

A<B return -1；

注意：是一个字节一个字节地比较！

四、memset（）

void *memset( void *dest. int c, size_t count):

?例子1：

size_t count 依然表示字节数

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[20] = "abcdefghijklmn";
	memset(arr, 'x', 6);
	printf("%s",arr); 
	return 0;
}

output xxxxxxghijklmn

例子2：

#include<stdio.h>
#include<string.h>
int main()
{

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memset(arr, 0, 9);
	for (int i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	return 0;
}

ouyput 0 0 0 4 5 6 7 8 9 10

?原内存：01 00 00 00 02 00 00 00 00 03?00 00 00 04?00 00 00 00......

修改后：00?00 00 00 00?00 00 00 00 00?00 00 00 04?00 00 00 00.......（将前面9个字节改为0）