c_character_string 字符串----我认真的弄明白了，也希望你们也是。

不断提高

已于 2023-02-10 15:16:52 修改

阅读量607

点赞数

分类专栏： c语言文章标签： c语言 c++ 算法

于 2023-02-10 15:09:19 首次发布

本文链接：https://blog.csdn.net/weixin_45075787/article/details/128970513

版权

c语言专栏收录该内容

22 篇文章 1 订阅

订阅专栏

字符串

1. 字符串长度strlen

1.1strlen 函数介绍

size_t strlen ( const char * str );

strlen ——string length
strlen 的头文件是 #include <string.h>
参数指向的字符串必须要以 ‘\0’ 结束。
strlen 是求字符串长度的函数，统计的是字符串中\0之前出现的字符个数（不包含 ‘\0’ )。
注意函数的返回值为size_t，是无符号的。

示例1：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = { 'a','b','c','d','e','f' };
	char arr3[9] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));
	printf("%d\n", strlen(arr3));
	return 0;
}

打印：
6
12
6
arr1 是字符串，字符串的结束标志是 \0,所以 strlen 计算的是 \0之前出现的字符个数,所以是6。
arr2 是字符，arr2 里面没有 \0, 所以 strlen 计算的时候会一直往下计算直到遇到 \0 才会停下，是个随机值。
arr3 是字符串数组,数组数量为6个,所以才会打印6。

示例2：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "abc";
	char arr2[] = "abcdef";
	if (strlen(arr1) - strlen(arr2) > 0)
		printf(">\n");
	else
		printf("<\n");
	return 0;
}
运行结果：
大于

strlen 计算出 arr1 的值是3，arr2 的值是6，arr1 - arr2 = -3 <0; 怎么会打印 > 呢？
因为函数的返回值为size_t，是无符号的。arr1 和 arr2 的返回值是无符号的，两个无符号的值相减的结果也是无符号的，即使结果是-3 也会被当成无符号数处理，一定会大于0，打印的结果就是 > 。

1.2 strlen 函数的模拟实现

方法一：计数器方式

#include <stdio.h>
#include <string.h>
size_t my_strlen(const char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

方法二：指针-指针的方式

#include <stdio.h>
#include <string.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
	assert(str);//确保str不为空指针
	const char* start = str;
	const char* end = str;
	while (*end != '\0')
	{
		end++;
	}
	return end - start;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

方法三：不能创建临时变量计数器（递归求解）

#include <stdio.h>
#include <string.h>
size_t my_strlen(const char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

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

长度不受限制的字符串和字符串长度没有关系，只关心\0

2.1 strcpy

2.1.1 strcpy 函数介绍

char *strcpy(char *dest, const char *src);

strcpy 的头文件是 #include <string.h>
源字符串必须以 ‘\0’ 结束。
strcpy 会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。注意：常量字符串不可以修改不可以放到目标空间里。

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	
	printf("%d\n", strlen(arr1));
	printf("%d\n",  strlen(arr2));
	return 0;
}

运行结果:
hello
5
5  //strcpy 会将源字符串中的 ‘\0’ 拷贝到目标空间。

2.1.2 strcpy 函数模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* str)//str加const确保str不被修改
{
	assert(dest);
	assert(str);
	char* ret = dest;
	while (*dest++ = *str++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "abc";
	char arr2[] = "hello word";
	printf("%s\n", my_strcpy(arr1, arr2));
	return 0;
}

运行结果：hello word

2.2 strcat

2.2.1 strcat 函数介绍

char *strcat(char *dest, const char *src)

strcat 字符串追加函数，头文件是 #include <string.h>，把源字符串追加到目标字符串，在目标字符串的\0后处开始追加，遇到源字符串的\0停止追加。追加的时候会把源字符串的\0一起追加到目标字符串。
源字符串必须以 ‘\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
strcat 不可以自己追加自己，容易出现死循环。

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[20] = "hello \0xxxxxxxx";
	char arr2[] = "word";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

运行结果： hello word

2.2.2 strcat 函数模拟

#include <stdio.h>
#include <string.h>
char* my_strcat(char* dest, const char* str)
{
	//1.找目标空间中的\0
	char* cur = dest;
	while (*cur != '\0')
	{
		cur++;
	}
	//2.拷贝源头数据到\0之后的空间
	while (*cur++ = *str++)  //*str++ 优先级都是一样的情况下，先右到左
	{
		;
	}
	return dest;
}
int main()
{
	char arr1[20] = "hello \0xxxxxxxx";
	char arr2[] = "word";
	printf("%s\n", my_strcat(arr1, arr2));
	return 0;
}

运行结果：
    hello word

2.3 strcmp

2.3.1 strcmp 函数介绍

extern int strcmp(const char *s1,const char *s2);

strcmp 是比较字符串的库函数，头文件是 #include <string.h>，比较的是对应位置上字符的大小（ASCII码值的大小）而非长度
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	/*char arr1[] = "abcdef";
	char arr2[] = "abc";*/
	
	/*char arr1[] = "abc";
	char arr2[] = "abcd";*/

	char arr1[] = "abc";
	char arr2[] = "abc";

	int ret = strcmp(arr1, arr2);
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret < 0)
		printf("arr1<arr2\n");
	else
		printf("arr1==arr2\n");
	
	printf("%d\n", ret);
	return 0;
}

//运行结束：
	//等于 ret = 0

2.3.2 strcmp 函数模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
//方法一
/*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 my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	return *s1 - *s2;
 //返回两个字符ASCII相减的值
}

int main()
{
	/*char arr1[] = "abcdef";
	char arr2[] = "abc";*/

	char arr1[] = "ad";
	char arr2[] = "aa";

	/*char arr1[] = "abc";
	char arr2[] = "abc";*/

	int ret = my_strcmp(arr1, arr2);
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret < 0)
		printf("arr1<arr2\n");
	else
		printf("arr1==arr2\n");

	printf("%d\n", ret);
	return 0;
}
 //运行结果：
  	arr1>arr2
	3

3. 长度受限制的字符串函数介绍

3.1 strncpy 函数介绍

char *strncpy(char *destinin, char *source, int maxlen);

strncpy 的头文件是 #include <string.h>
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加NULL，直到num个

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[20] = "abcdefrtjujghbv";
	char arr2[] = "xxxx12";
	char arr3[] = "qwertyuio";
	
	strncpy(arr1, arr2, 7);
	printf("%s\n", arr1);
	
	strncpy(arr1, arr3, 3);
	
	printf("%s\n", arr1);
	return 0;
}

//运行结果：
	xxxx12
	qwex12

3.2 strncat 函数介绍

char * strncat(char *dest, const char *src, size_t n);

strncat 的头文件是 #include <string.h>
strncat 和 strncpy 的使用非常相似，strncat是追加num个字符从源字符串到目标空间。
strncat 追加完成后会自己添加\0。
strncat 可以自己追加自己

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "xyz";
	strncat(arr1, arr2, 2);
	printf("%s\n", arr1);
	
	strncat(arr2, arr2, 5);
	printf("%s\n", arr2);
	return 0;
}

//运行结果：
	abcdefxy
	xyzxyz

3.3 strncmp 函数介绍

int strncmp(const char *str1, const char *str2, size_t n)

strmcpy 的头文件是 #include <string.h>
strncmp 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
如果返回值 < 0，则表示 str1 小于 str2。
如果返回值 > 0，则表示 str2 小于 str1。
如果返回值 = 0，则表示 str1 等于 str2。

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "abd";
	int ret = strcmp(arr1, arr2, 3);
	printf("%d\n", ret);
	return 0;
}

//运行结果：
-1

4. 字符串查找

4.1 strstr

4.1.1 strstr 函数介绍

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

strstr 字符串查找函数，头文件是 #include <string.h>，在一个字符串中查找另外一个字符串是否存在，如果存在，则返回子串第一次出现的位置；不存在，则返回NULL。
如果找到了该子串，会从找到的地方开始输出

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "abcdefabcdef";
	char arr2[] = "def";
	char* p = strstr(arr1, arr2);
	if (p == NULL)
	{
		printf("不存在\n");
	}
	else
	{
		printf("%s\n", p);
	}
	return 0;
}

//运行结果：
	defabcdef

4.1.2 strstr函数模拟实现

#include <stdio.h>
#include <string.h>
char* my_strstr(const char* str1, const char* str2)
{
	const char* s1 = str1;
	const char* s2 = str2;
	const char* p = str1;
	while (*p)
	{
		s1 = p;
		s2 = str2;
		while ((*s1 != '\0') && (*s2 != '\0') && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)p;//找到了
		}
		p++;
	}
	return NULL;//找不到子串
}
int main()
{
	char arr1[] = "abcdefabcdef";
	char arr2[] = "fab";
	char* p = my_strstr(arr1, arr2);
	if (p == NULL)
	{
		printf("不存在\n");
	}
	else
	{
		printf("%s\n", p);
	}
	return 0;
}

//运行结果:
	fabcdef

4.2 strtok 函数介绍

char *strtok(char s[], const char *delim);

strtok 的头文件是 #include <string.h>
sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "zhangsan@qq.com";
	char buf[100] = { 0 };
	strcpy(buf, arr);//将数据拷贝一份，处理buf中arr数组的内容
	const char* sep = "@.o";//sep定义了用作分隔符的字符集合
	char* str = NULL;
	for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}
	return 0;
}

//运行结果：
	zhangsan
    qq
    c
    m

5. 字符分类函数

后续添加

6. 字符串转换函数

int tolower ( int c );
int toupper ( int c );

转换函数把字母大写转换成字母小写；或者把字母小写转换成字母大写。
tolower 函数返回其参数对应的小写形式
toupper 函数返回其参数对应的大写形式
如果函数的参数并不是处于适当大小写状态的字符（即 toupper 的参数不是小写字母或者 tolower 的参数不是大写字母），函数将不修改参数直接返回。

示例：

后续添加

7. 内存操作函数

7.1 memcpy

7.1.1 memcpy函数介绍

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

memcpy 是内存拷贝函数，头文件是 #include <string.h>；num的单位是字节。
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。
memcpy 的参数类型是void*可以接收任意类型的数据。

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0};
	memcpy(arr2, arr1, 20);//把arr1的前20个字节的数拷贝到arr2里面去，一个int是4字节
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

//运行结果：
	1 2 3 4 5 0 0 0 0 0

7.1.2 memcpy 函数模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* dest, void* src, size_t num)
{
	void* ret = dest;
	assert(dest);
	assert(src);//断言，让dest和src不为空指针
	while (num--)
	{
		*(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[10] = { 0};
	my_memcpy(arr2, arr1, 20);//把arr1的前20个字节的数拷贝到arr2里面去
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

//运行结果：

	1 2 3 4 5 0 0 0 0 0

7.2 memmove

7.2.1 memmove 函数介绍

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

memmove和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
memcpy 只需要实现不重叠的拷贝就可以了。
memmove 是需要实现重叠内存的拷贝。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1+2, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

//运行结束：
	1 2 1 2 3 4 5 8 9 10

7.2.2 函数模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memmove(void* dest, void* src, size_t num)
{
	void* ret = dest;
	assert(dest);
	assert(src);//断言，让dest和src不为空指针
	if (dest < src)//1 前->后
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;//一个字节一个字节的处理
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else //2 3 后->前
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}
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;
}

7.3 memcmp 函数介绍

int memcmp(const void *str1, const void *str2, size_t n);

memcmp 的头文件是 #include <string.h>
memcmp 比较从ptr1和ptr2指针开始的num个字节。一个字节一个字节比较。
str1-- 指向内存块的指针。
str2-- 指向内存块的指针。
n-- 要被比较的字节数。 
strcmp是比较字符大小，这个是比较字节大小。

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00...
	int arr2[] = { 1,2,3,0,0 };//01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00...
	int ret = memcmp(arr1, arr2, 13);
	printf("%d\n", ret);
	return 0;
}

//运行结果：
	1

7.4 memset 函数介绍

void *memset(void *s, int ch, size_t n);

memset 内存设置函数，头文件 #include <stdio.h>
将 ptr 设置为 value 值，num个字节。以字节为单位修改内存。
函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法 [1]  。
memset()函数原型是extern void *memset(void *buffer, int c, int count) buffer：为指针或是数组,c：是赋给buffer的值,count：是buffer的长度.

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	memset(arr, 0, 9);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

7.4 memset 函数介绍

void *memset(void *s, int ch, size_t n);

memset 内存设置函数，头文件 #include <stdio.h>
将 ptr 设置为 value 值，num个字节。以字节为单位修改内存。
函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法 [1]  。
memset()函数原型是extern void *memset(void *buffer, int c, int count) buffer：为指针或是数组,c：是赋给buffer的值,count：是buffer的长度.

示例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	memset(arr, 0, 9);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}