进阶第三节-字符函数和字符串函数

已于 2023-08-24 17:28:51 修改
阅读量44 收藏
点赞数
文章标签： c语言
于 2023-08-22 13:45:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68124969/article/details/132425189
版权

1. 函数介绍

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

1.1.1 strlen

size_t strlen ( const char * str );

  • 1、字符串已经'\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数
  • （不包 含'\0')。
  • 2、参数指向的字符串必须要以 '\0' 结束。
  • 3、注意函数的返回值为size_t，是无符号的
  • 4、学会strlen函数的模拟实现
#include<stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "abc";
	char arr2[] = { 'a', 'b', 'c' };

	int len1 = strlen(arr1);
	int len2 = strlen(arr2);

	printf("%d\n", len1);//3
	printf("%d\n", len2);//随机值
	return 0;
}


//strlen的模拟实现
#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
	size_t count = 0;//计数器
	assert(str != NULL);
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abc";
	size_t len  = my_strlen(arr);//3
	printf("%d\n", len);
	return 0;
}
#include <stdio.h>
#include <string.h>
int main()
{
	if (my_strlen("abc") - my_strlen("abcdef") > 0)
	{
		printf(">\n");//>
	}
	else
	{
		printf("<=\n");
	}
	return 0;
}

1.1.2 strcpy (字符串拷贝)

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

  • 1、将字符串source复制到destination指向的的数组中，包括终止空字符\0

           （并在该点停止）

  • 2、源字符串必须以 '\0' 结束。
  • 3、会将源字符串中的 '\0' 拷贝到目标空间。
  • 4、目标空间必须足够大，以确保能存放源字符串。
  • 5、目标空间必须可变。
  • 6、学会模拟实现。
#include <stdio.h>
#include <string.h>
int main()
{
	char name1[20] = { 0 };
	strcpy(name1, "hello");//string copy
	//name1 = "hello";//err - name1数组名是地址，地址是一个常量，不能被赋值
	printf("%s\n", name1);//hello

	char name2[20] = { 0 };
	strcpy(name2, "zhang\0san");
	printf("%s\n", name2);//zhang - 把\0也拷贝过去了

	char name3[20] = "xxxxxxxxxx";
	strcpy(name3, "zhang\0san");
	printf("%s\n", name3);//zhang - 在内存中显示zhang\0xx

	char name4[20] = "xxxxxxxxxx";
	char arr[] = {'b', 'i', 't'};
	strcpy(name4, arr);//err - 源数据没有\0
	printf("%s\n", name4);

	char name5[3] = "";
	char arr1[] = "abcdef"
	strcpy(name5, arr);//err - 目标空间不够大，造成越界访问
	printf("%s\n", name5);

	char* p = "abcdef";
	char arr2[] = "bit";
	strcpy(p, arr2);//err - 目标区域不可修改
	printf("%s\n", p);

	return 0;
}

 1.1.3 strcat (字符串追加)

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

  • 1、将源字符串的副本追加到目标字符串。目的地中的终止空字符（\0）被源的第一个字符覆盖，并且空字符被包括在由目的地中两者的串联形成的新字符串的末尾。
  • 2、源字符串必须以 '\0' 结束。
  • 3、目标空间必须有足够的大，能容纳下源字符串的内容。
  • 4、会将源字符串中的 '\0' 拷贝到目标空间。
  • 5、目标空间必须可修改。
  • 6、字符串自己给自己追加，如何？
//自己给自己追加

#include <stdio.h>
#include <assert.h>
char* my_strcat(char* dest, const char*src)
{
	char* ret = dest;
	assert(dest && src);
	//1. 找目标字符串中的\0
	while (*dest != '\0')
	{
		dest++;
	}
	//2. 追加源字符串,包含\0
	while(*dest++ = *src++)
	{
		;
	}
	return ret;//返回的目标空间的起始地址
}
int main()
{
	//自己给自己追加
	char arr[20] = "hello ";
	my_strcat(arr, arr);
	printf("%s\n", arr);//死循环 
	//由于原本"hello "末尾的'\0'被'h'所覆盖，所以拷贝"hello "的时候末尾没有'\0'，陷入死循环
	return 0;

1.1.4 strcmp (字符串比较)

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

  • 1、此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续进行以下配对直到字符不同或者直到到达终止的空字符。
  • 2、第一个字符串大于第二个字符串，则返回大于0的数字
  • 3、第一个字符串等于第二个字符串，则返回0
  • 4、第一个字符串小于第二个字符串，则返回小于0的数字
  • 5、那么如何判断两个字符串？

#include <stdio.h>
#include<string.h>
int main()
{
	//strcmp - 字符串比较大小的
	//比较一下两个字符串是否相等
	//比的是ASCII值
	//arr1是数组名，数组名是数组首元素的地址
	//arr2是数组名，数组名是数组首元素的地址

	char arr1[] = "zhangsan";
	char arr2[] = "zhangsanfeng";
	int ret = strcmp(arr1, arr2);//<0
	//int ret = strcmp("abbb", "abq");//<0
	printf("%d\n", ret);
	
	if (ret < 0)
		printf("<\n");
	else if (ret == 0)
		printf("==\n");
	else 
		printf(">\n");
	return 0;
}

1.2长度受限制的字符串函数 

1.2.1 strncpy

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

  • 1、将字符串source的前num个字符复制到目标。如果在复制num个字符之前找到了source字符串的末尾（由空字符发信号通知），则会用\0填充目标，直到总共写入num个字符为止。
  • 2、拷贝num个字符从源字符串到目标空间。
  • 3、如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。 
#include <stdio.h>
#include<string.h>
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "qwer";
	strncpy(arr1, arr2, 4);
	printf("%s\n", arr1);//qweref

	strncpy(arr1, arr2, 5);//把前4个字符覆盖过去后，多余的一个字符用\0
	printf("%s\n", arr1);//qwer 
	return 0;
}

1.2.2 strncat 

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

  • 1、将源的前num个字符追加到目标，再加上一个终止的null字符（\0）。
  • 2、如果源中的字符串的长度小于num，则只有终止之前的内容空字符被复制。
#include <stdio.h>
#include<string.h>
int  main()
{
	char arr1[20] = "hello ";
	char arr2[] = "word";
	strncat(arr1, arr2, 3);
	printf("%s\n", arr1);//hello wor

	char arr3[20] = "hello\0xxxxxx";
	char arr4[] = "world";
	strncat(arr3, arr4, 3);//先追加3个字符(首字符把目标字符串中的\0覆盖掉)，然后最后补上一个\0
	printf("%s\n", arr3);//hellowor - 在内存中显示hellowor\0xxx

	char arr5[20] = "hello\0xxxxxx";
	char arr6[] = "bit";
	strncat(arr5, arr6, 6);//把所有字符追加过去并补上一个\0后，多余的字符不管
	printf("%s\n", arr5);//hellobit - 在内存中显示hellobit\0xxx
	return 0;
}

 1.2.3 strncmp

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

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

#include <stdio.h>
#include<string.h>
int main()
{
	char* p = "abcdef";
	char* q = "abc";
	int ret = strncmp(p, q, 4);
	printf("%d\n", ret);//1
	if (ret < 0)
		printf("<\n");
	else if (ret == 0)
		printf("==\n");
	else 
		printf(">\n");//>
	return 0;
}

1.3 strstr (查找子串的函数)

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

返回指向str1中第一个出现的str2的指针，如果str2不是str1的一部分，则返回null指针   （str2是子串）

#include <stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "zpw@bitejiuyeke.com";
	char arr2[] = "bitejiuyeke";

	//在arr1中查找是否包含arr2数组
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("子串不存在\n");
	}
	else
	{
		printf("子串找到了：%s\n", ret);//子串找到了：bitejiuyeke.com
	}
	return 0;
}

1.4 strtok (切割字符串)

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

  • 1、sep参数是个字符串，定义了用作分隔符的字符集合
  • 2、第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
  • 3、strtok函数找到str中的下一个标记，并将其用\0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串（把标记改为\0），所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
  • 4、strtok函数的第一个参数不为NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
  • 5、strtok函数的第一个参数为NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
  • 6、如果字符串中不存在更多的标记，则返回NULL 指针。 
#include <stdio.h>
#include<string.h>
int main()
{
	char arr[] = "zpw@bitejiuyeke.com";
	char* sep = "@. ";//定义标记
	char cp[30] = { 0 };
	strcpy(cp, arr);//"zpw@bitejiuyeke.com"
	char* ret = NULL;

	//ret = strtok(cp, sep);//"zpw\0bitejiuyeke.com"
	//printf("%s\n", ret);//zpw

	//ret = strtok(NULL, sep);//"bitejiuyeke\0com"
	//printf("%s\n", ret);//bitejiuyeke

	//ret = strtok(NULL, sep);
	//printf("%s\n", ret);//com

	for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}

 1.5 strerror与perror

strerror：

char * strerror ( int errnum );

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

perror：

void perror ( const char * str );

//使用库函数的时候
//调用库函数失败的是，都会设置错误码

#include <stdio.h>
#include <errno.h>
#include <string.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));
	//printf("%s\n", strerror(5));

	//errno - C语言设置的一个全局的错误码存放的变量
	FILE* pf = fopen("test.txt", "r");//打开文件
	if (pf == NULL)
	{
        //strerror是把错误代码转化成错误信息然后再使用printf打印出来
        //perror是把错误代码转化成错误信息然后再直接打印出来
		printf("%s\n", strerror(errno));//No such file or directory
        perror("fopen");//fopen: No such file or directory
		return 1;
	}
	else
	{
		;
	}
	return 0;
}

 1.6 memcpy(内存拷贝)

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

  • 1、函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
  • 2、这个函数在遇到 '\0' 的时候并不会停下来。
  • 3、如果source和destination有任何的重叠，复制的结果都是未定义的。
  • 4、memcpy函数负责拷贝两块不重叠的内存（memcpy - 只要实现了不重叠拷贝就可以了,而VS中的实现既可以拷贝不重叠，也可以拷贝重叠内存）

 1.7 memmove(内存拷贝)

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

  • 1、和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
  • 2、如果源空间和目标空间出现重叠，就得使用memmove函数处理。

 1.8 memcmp(内存比较)

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

比较从 ptr1和 ptr2两个地址开始num个字节的内容

#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,2 };
	//在内存中01 00 00 00 02 00 00 00 02 00 00 00
	int ret = memcmp(arr1, arr2, 12);
	printf("%d\n", ret);//输出大于0的数：1
	return 0;
}

 1.9 memset(字符串设置)

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

ptr是要设置空间内存的起始地址，value是要设置的值，num是设置的字节数

//内存设置
#include <stdio.h>
#include<string.h>
int main()
{
	char ch[] = "hello bit";
	memset(ch, 'x', 5);
	printf("%s\n", ch);//xxxxx bit

	int arr[10] = { 0 };
	memset(arr, 1, 40);//以字节为单位设置内存，每个字节设置为1
	//00 00 00 00
	//01 01 01 01

    char arr[10] = { 0 };
	memset(arr, 1, 10);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);//1 1 1 1 1 1 1 1 1 1
	}
	return 0;
}

2. 库函数的模拟实现 

2.1 模拟实现strlen

//计数器方式
//代码1
#include<stdio.h>
int my_strlen(const char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d\n", ret);//6
	return 0;
}


//不能创建临时变量计数器(函数递归)
//代码2
#include<stdio.h>
int my_strlen(const char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d\n", ret);//6
	return 0;
}


//指针-指针的方式
//代码3
#include<stdio.h>
int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
		p++;
	return p - s;//两个指针之间的元素个数(不包括\0)
}
int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d\n", ret);//6
	return 0;
}

2.2 模拟实现strcpy

//1.参数顺序
//2.函数的功能，停止条件
//3.assert
 //4.const修饰指针
//5.函数返回值
//6.题目出自《高质量C/C++编程》书籍最后的试题部分

//模拟实现strcpy
#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
	assert(dest);
	assert(src);
	char* ret = dest;//拷贝dest的起始地址
	while (*dest++ = *src++)//可以把\0也赋值过去
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "abcdef";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);//abcdef
	return 0;
}

2.3 模拟实现strcat 

//模拟实现strcat

#include <stdio.h>
#include <assert.h>
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	//1. 找目标字符串中的\0
	while (*dest != '\0')
	{
		dest++;
	}
	//2. 追加源字符串,包含\0
	while (*dest++ = *src++)
	{
		;
	}
	return ret;//返回的目标空间的起始地址
}
int main()
{
	//字符串追加
	char arr1[20] = "hello ";//world
	char arr2[] = "world";
	//'w'把"hello "末尾的\0给覆盖了，并且会追加"world"末尾的\0
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);//hello word
	return 0;
}

2.4 模拟实现strcmp 

//模拟实现strcmp

//代码1
#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	if (*str1 > *str2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}
int main()
{
	char* p = "abcdef";
	char* q = "abc";
	int ret = my_strcmp(p, q);
	if (ret > 0)
		printf("p > q\n");
	else if (ret < 0)
		printf("p < q\n");
	else
		printf("p == q\n");
	return 0;
}


//代码2
#include <stdio.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++;
	}
	return (*s1 - *s2);
}
int main()
{
	char* p = "abcdef";
	char* q = "abc";
	int ret = my_strcmp(p, q);
	if (ret > 0)
		printf("p > q\n");
	else if (ret < 0)
		printf("p < q\n");
	else
		printf("p == q\n");
	return 0;
}

2.5 模拟实现strstr

//strstr模拟实现

#include <stdio.h>
#include<string.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* p = str1;//将str1进行拷贝
	while (*p)
	{
		s1 = p;
		s2 = str2;//将str2进行拷贝
		while (*s1 != '\0' && *s2 != '\0' && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)p;
		}
		p++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "zpw@bitejiuyeke.com";
	char arr2[] = "bitejiuyeke";

	//在arr1中查找是否包含arr2数组
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("子串不存在\n");
	}
	else
	{
		printf("子串找到了：%s\n", ret);//子串找到了：bitejiuyeke.com
	}
	return 0;
}

2.6 模拟实现memcpy 

//内存操作函数
//memcpy - 内存拷贝
//memcpy模拟实现

#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);

	while (num--)//4 3 2 1
	{
		*(char*)dest = *(char*)src;
        //不能使用++，因为(char*)是一种临时状态，++后强制类型的效果过去了
		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);
	return 0;
}

2.7 模拟实现memmove

//memmove函数可以处理内存重叠的情况
//模拟实现memmove

#include <stdio.h>
#include <assert.h>
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--)//20先使用，后--
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	               //1 2 1 2 3 4 5 8 9 10
	my_memmove(arr1+2, arr1, 20);//1 2 1 2 3 4 5 8 9 10
	//memmove(arr1, arr1+2, 20);//3 4 5 6 7 6 7 8 9 10
	//my_memcpy(arr1+2, arr1, 20);//1 2 1 2 1 2 1 8 9 10
	//memcpy(arr1 + 2, arr1, 20);//1 2 1 2 3 4 5 8 9 10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

m0_68124969
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值