字符串函数

目录

strlen

strcpy

strcat

strcmp

strncpy

strncat

strncmp

strstr

strtok

strerror

perror

memcpy

memmove

memcmp

memset

strlen

size_t strlen ( const char * str );

● 字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' )

● 参数指向的字符串必须要以 '\0' 结束

#include <stdio.h>
int main()
{
	const char* str = "hello world";
	printf("%d\n", strlen(str)); //11

	char arr[] = { 'a', 'b', 'c' }; 
	printf("%d\n", strlen(arr)); //随机值
	return 0;
}

● 注意函数的返回值为size_t，是无符号的（ 易错 ）

str2长度是 < str2长度的，因此减完之后是负数，但size_t是无符号的，所以返回值会被解析成一个很大的数字，因此就匹配到了else

#include <stdio.h>
int main()
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";
	if (strlen(str2) - strlen(str1) > 0)
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("srt1>str2\n"); //str1>str2
	}
	return 0;
}

strlen 模拟实现

1.计数器

字符串以'\0'结尾，因此用一个count 变量，统计到指针指向'\0 为止

int my_strlen(const char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

2.递归(不创建临时变量)

相同的子问题: 当前字符 + 剩余字符串的长度

递归结束条件: 遇到\0

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

3.指针-指针

指针 - 指针 得到的是两个指针之间的元素个数，因此让指针指向\0, 减去指向字符串最开始的指针

int my_strlen(char* s)
{
    char* p = s;
    while (*p != '\0')
        p++;
    return p - s;
}

strcpy

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

● 源字符串必须以 '\0' 结束

● 会将源字符串中的 '\0' 拷贝到目标空间

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

● 目标空间必须可变

#include <stdio.h>
int main()
{
	const char* src = "hello world\n";
	char dst[100];
	strcpy(dst, src);
	printf("%s\n", dst); //hello world
	return 0;
}

strcpy 模拟实现

● 拷贝src指向的字符串到 dst指向的 字符串， 一直拷贝到遇到了src的\0位置

● *的优先级高于后置++，因此先解引用进行逐个字符的拷贝，指针再++

● 先赋值，再while判断，因此当dst最后遇到\0后，赋值给src, 结束循环

● 使用assert断言，可以增强代码的健壮性, 传入空指针程序直接崩溃

● my_strcpy的返回值是char*，获取到目标空间的起始地址

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

strcat

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

● 字符串必须以 '\0' 结束。

● 目标空间必须有足够的大，能容纳下源字符串的内容。

● 目标空间必须可修改。

● 不能自己给自己追加

#include <stdio.h>
int main()
{
	const char* src = "world";
	char dst[100] = "hello ";
	strcat(dst, src);
	printf("%s\n", dst); //hello world
	return 0;
}

strcat 模拟实现

char* my_strcat(char* dest, const char* src)
{
	//1.找到\0
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while (*dest)
	{
		dest++;
	}
	//2.逐个字符追加
	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}

strcmp

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

strcmp用于比较两个字符串的大小，注意字符串比较大小，本质比较的是ASCII值

标准规定：

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

● 第一个字符串等于第二个字符串，则返回0

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

#include <stdio.h>
#include <assert.h>
int main()
{
	const char* s1 = "aorld";
	const char* s2 = "hello";
	int n = strcmp(s1, s2);
	if (n > 0)
	{
		printf("s1 > s2"); //s1 > s2
	}
	else if(n == 0)
	{
		printf("s1 == s2");
	}
	else
	{
		printf("s1 < s2");
	}
	return 0;
}

strncpy

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

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

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

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
int main()
{
	char* src = "hello world";
	char dst1[40];
	char dst2[40];
	strncpy(dst1, src, 7); //hello w+随机值
	strncpy(dst2, src, 15); //hello world
	printf("%s\n", dst1);
	printf("%s\n", dst2);
	return 0;
}

strncat

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

● 追加 src字符串 的 num 个字符到 dst 字符串后面

● 如果src字符串的个数不够num个，则在后面补 \0

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
int main()
{
	char* src = "xxxxxxxxxxxx";
	char dst1[40] = "hahaha";
	char dst2[40] = "hahaha";
	strncat(dst1, src, 7); //hahahaxxxxxxx
	strncat(dst2, src, 18); //hahahaxxxxxxxxxxxx
	printf("%s\n", dst1);
	printf("%s\n", dst2);
	return 0;
}

strncmp

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

strncmp 用于比较两个字符串的前num个字符是否相等

● 比较到任何一个字符串结尾，就结束

● 比较了 num 个字符，就结束

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
int main()
{
	const char* s1 = "hello world";
	const char* s2 = "hello worxx";
	printf("%d\n", strncmp(s1, s2, 5)); //0
	printf("%d\n", strncmp(s1, s2, 10)); //-1
	printf("%d\n", strncmp(s1, s2, 15)); //-1
	return 0;
}

strstr

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

strstr 用于判断一个字符串是否包含在另一个字符串中

●  str2 在 str1中，返回str2在str1中首次出现的地址

●  str2 不在 str1中，返回空指针

#pragma warning(disable:4996)
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main()
{
	const char* s1 = "I am a student";
	const char* s2 = "am";
	char* ret = strstr(s1, s2);
	char str[10] = {0};
	if (ret != NULL)
	{
		strncpy(str, ret, 2);
		printf("%s\n", str); //am
	}
	else
	{
		printf("s2 is not in s1");
	}
	return 0;
}

strstr 模拟实现

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1);
	assert(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都没到结束并且对应字符相等
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0') //s2遍历完了，说明匹配了
		{
			return p;
		}
		p++;
	}
}

strtok

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

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

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

● strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。

（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

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

● strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。

● 如果字符串中不存在更多的标记，则返回 NULL 指针。

写法一: while循环

#include <stdio.h>
int main()
{
	char* p = "dck@qq.com";
	const char* sep = ".@"; //字符串分隔符
	char arr[30]; 
	strcpy(arr, p);
	char* str = NULL; 
	str = strtok(arr, sep);
	while(str != NULL)
	{
		printf("%s ", str); //dck qq com
		str = strtok(NULL, sep);
	}
}

写法二: for循环

#include <stdio.h>
int main()
{
	char* p = "dck@qq.com";
	const char* sep = ".@"; //字符串分隔符
	char arr[30]; 
	char* str = NULL; 
	strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s ", str); //dck qq com
	}
}

strerror

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

char * strerror ( int errnum );

errno 是C语言的一个全局变量,  当库函数执行报错时，就会将报错信息以数字1, 2, 3等等的方式设置进errno, 但是数字是不方便人看的，因此我们可以用 strerror 库函数将错误码对应的错误信息以字符串方式表示出来

#pragma warning(disable:4996)
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno)); //No such file or directory
	}
	return 0;
}

我们可以采用for循环的方式打印查看各个数字对应的错误信息

#pragma warning(disable:4996)
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
	FILE* pf = fopen("test.txt", "r");
	for(int i = 0; i < 20; i++)
	{
		printf("%s\n", strerror(i)); 
	}
	return 0;
}

perror

void perror ( const char * str );

● perror 和 strerror 作用一样，以字符串形式打印错误信息

● perror 的功能相当于 strerror + printf

● perror 参数是传入的字符串，最后打印形式是 传入的字符串: 错误信息

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("open file fail: "); //open file fail: No such file or directory
	}
	return 0;
}

memcpy

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

● 上面的字符串函数都是处理字符串的，但如果想拷贝整形、浮点型等类型的数据，字符串函数是无法使用的，只能用memcpy函数，因为memcpy是以字节为单位拷贝的

● 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

● 这个函数在遇到 '\0' 的时候并不会停下来

● 如果source和destination有任何的重叠，复制的结果都是未定义的

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

memcpy模拟实现

void* my_memcpy(void* dst, void* src, int num)
{
	assert(dst);
	assert(src);
	void* ret = dst;
	while (num--)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}

● memcpy 实现的是字节拷贝，并不知道用户会拷贝什么类型的数据，因此参数是 void*

● 拷贝完之后，目标空间发生了变化，期望返回目标空间的起始地址

● void* 指针无法解引用与++， 因此先转化成char*, 再进行解引用赋值和++

注意:

1. 标准规定，memcpy 只能用于拷贝不重叠空间的数据，而无法解决拷贝重叠空间的问题，因为拷贝时发生了覆盖!

2. 但是实现时 memcpy 可以实现拷贝重叠空间，但标准并没有这样规定，标准规定的是 memcpy 用于拷贝不重叠空间的数据，而 拷贝重叠空间交给memmove

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* dst, void* src, size_t num)
{
	assert(dst);
	assert(src);
	void* ret = dst;
	while (num--)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	my_memcpy(arr1 + 2, arr1, 20); //拷贝arr2前8个字节到arr1中
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]); //1 2 1 2 1 2 1 8 9 10
	}
	return 0;
}

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	memcpy(arr1 + 2, arr1, 20); //拷贝arr2前8个字节到arr1中
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]); //1 2 1 2 3 4 5 8 9 10
	}
	return 0;
}

memmove

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

● memcpy 无法解决拷贝重叠空间的数据的问题, 而memmove可以拷贝重叠空间的数据

● memmove的参数与memcpy完全一致

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
#include <assert.h>
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	memmove(arr1 + 2, arr1, 20); //拷贝arr2前20个字节(5个整数)到arr1中
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]); //1 2 1 2 3 4 5 8 9 10
	}
	return 0;
}

memmove模拟实现

经过分析，只要判断 src 和 dst 大小关系，从而决定是从前向后拷贝还是从后向前拷贝就可以避免数据被覆盖的问题

void* my_memmove(void* dst, void* src, int num)
{
	assert(dst);
	assert(src);
	void* ret = dst;
	if (src > dst)
	{
		//本质就是memcpy的实现
		while (num--)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			//从后向前一个字节一个字节拷贝
			*((char*)dst + num) = *((char*)src + num);
		}
	}
	return ret;
}

memcmp

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

● 比较两块内存空间的前num个字节的大小

● 逐个字节比较，相等继续往后比，直到不想等或者 其中一个字符串已经走到结尾

● 返回值和strcmp是一样的

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5};
	int arr2[] = { 1, 2, 3, 6, 7};
	int n1 = memcmp(arr1, arr2, 10);
	int n2 = memcmp(arr1, arr2, 16);
	printf("%d\n", n1); //0
	printf("%d\n", n2); //-1
	return 0;
}

memset

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

● 内存设置函数，用于初始化一块内存空间，将ptr指向内存空间的前num个字节初始化 value

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "hello world";
	memset(arr, 'x', 11);
	printf("%s\n", arr); //xxxxxxxxxxx
	return 0;
}

● memset 是以字节为单位进行初始化的，因此不要误用

比如下面代码中，想要用 memset 将arr数组的每个值都初始化成1，但memset是以字节为单位初始化，因此每个int的值会变成 01 01 01 01(十六进制), 没有达到预期结果

#include <stdio.h>
#include <string.h>
int main()
{
	int arr[10] = { 0 };
	memset(arr, 1, 40);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]); //打印结果并不是全1
	}
	return 0;
}