C语言中的字符与字符串函数一把梭

目录

一、求字符串长度

1、strlen库函数如何使用?

2.如何模拟实现strlen函数

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

1.库函数 strcpy 如何使用?

2.如何模拟实现 strcpy 函数?

3.库函数 strcmp 如何实现?

4.strcmp 函数如何模拟实现?

5. 库函数 strcat 的使用

6. 如何模拟实现 strcat 

三、长度受限制的字符串函数

1. strncpy - 长度受限制的字符串拷贝函数

2.strncat - 长度受限制的字符串追加函数

3.strncmp - 长度受限制的字符串比较函数

四、字符串查找

1.strstr 如何使用呢?

2.strstr 模拟实现

3.strtok 字符串切割函数

五、错误信息报告

六、字符操作

七、内存操作函数

1.memcpy内存拷贝函数如何使用呢?

2.模拟实现 memcpy

3.重叠内存之间的数据拷贝

4.memmove 模拟实现

5.内存比较

6.内存设置


一、求字符串长度

strlen专门用来求字符串长度的函数(这里的长度指的是字符串字符的个数)。

1、strlen库函数如何使用?

#include
#include

int main()
{
    char arr[] = "abcdef";
    int len = strlen(arr);
    printf("%d\n", len);
    return 0;
}

输出结果:

 为什么会输出 6 呢?

解释:

strlen 从arr数组的第一个字符开始计算,遇到一个字符,个数加1,直到计算所有的字符后结束。

注意:字符串的结束标志是 '\0' ,计算字符串长度时不会计算 '\0' ,只会计算 '\0' 之前的字符。

strlen库函数的使用需要引用头文件!

2.如何模拟实现strlen函数

#include
#include

size_t my_strlen(const char* arr)
{
	assert(arr);
	size_t count = 0;
	while (*arr != '\0')
	{
		count++;
		arr++;
	}
	return count;
}

int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d\n", ret);
	return 0;
}

这个代码求的是arr数组的长度,结果是6。

assert(arr);这一句是断言,为的是确保数组首元素的地址传过来的时候不是一个 NULL

assert 函数的头文件:

count 记录的是字符个数,所以返回 count 就是返回字符串长度。

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

strcpy:字符串拷贝函数,专门用来拷贝字符串内容的函数。(将源空间的内容拷贝到目标空间)

1.库函数 strcpy 如何使用?

#include
#include

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "I love China!";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

strcpy 的第一个参数(arr1)表示目标空间第二个参数(arr2)表示源空间

它的头文件是:

代码的作用是将字符串 "I love China!" 拷贝到arr1中并打印出来。

输出结果:

  

 注意:strcpy 只是将目标空间的内容覆盖,自身源空间的内容并不会改变。

2.如何模拟实现 strcpy 函数?

#include
#include

char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*src)
	{
		*dest++ = *src++;
	}
	*dest = *src;//'\0'
	return ret;
}

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "I love China!";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

我们并不会改变源空间,所以加上 const 在我们不小心将其修改的时候对其进行保护。

代码的含义是:

        先将 dest 最开始指向的内容赋给 ret ,作为目标空间起始地址;*dest++ = *src++; 是将目标空间的字符给改成源空间的字符,直到源空间的字符全部改完。++ 就是指向下一个内容; src 是源空间拷贝结束后会指向 arr2 末尾的 '\0',*dest = *src; 就是将此时 src 指向的内是('\0') dest

3.库函数 strcmp 如何实现?

strcmp: 字符串比较函数,专门用来比较字符串内容的函数。

注意:字符串比较,比的是相同位置字符的 ASCII 码值的大小

例如:

char arr1[] = "abcde";
char arr2[] = "abcfg";

a, b, c 的 ASCII 码值一样大,所以前三个字符是相同大小的,比到第4个字符的时候,f 的 ASCII 码值大于 d ,所以 arr2 要大于 arr1

这个函数有两个参数,分别是要比较的字符串的地址。返回类型是 int 。

C语言中的字符与字符串函数一把梭_第1张图片

 返回值的解释:

如果第一个字符串小于第二个字符串,就返回 小于0 的数字;如果第一个字符串等于第二个字符串,就返回 0 ;如果第一个字符串大于第二个字符串,就返回 大于0 的数字;

#include
#include

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	int ret = strcmp(arr1, arr2);
	if (0 > ret)
	{
		printf("arr1 < arr2");
	}
	else if (0 == ret)
	{
		printf("arr1 == arr2");
	}
	else
	{
		printf("arr1 > arr2");
	}
	return 0;
}

strcmp 的头文件

输出结果:

C语言中的字符与字符串函数一把梭_第2张图片

4.strcmp 函数如何模拟实现?

#include
#include

int  my_strcmp(const char* arr1, const char* arr2)
{
	assert(arr1 && arr2);
	while (*arr1 == *arr2)
	{
		//等于的情况
		if (*arr1 == '\0')
		{
			return 0;
		}
		arr1++;
		arr2++;
	}
	return (*arr1 - *arr2);
}

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcd";
	int ret = my_strcmp(arr1, arr2);
	if (ret < 0)
	{
		printf("arr2 < arr1");
	}
	else if (ret == 0)
	{
		printf("arr2 == arr1");
	}
	else
	{
		printf("arr2 > arr1");
	}
	printf("%d\n", ret);
	return 0;
}

       当比较的字符相等时而且还未遇到结尾,循环和 ++ 操作符就可以指向下一个字符并比较,直到遇到末尾的 \0 。如果arr1指向了 \0 则说明两个字符串的所有字符都比较过了,结果还是相等,然后返回0。当比较出大小的时候,就返回 arr1 指向的内容减去 arr2 指向的内容。如果 arr1 大于 arr2 ,返回的就是大于 0 的数字,反之就是小于。

   

C语言中的字符与字符串函数一把梭_第3张图片

长度不受限制就是再使用的时候,不能限制进行操作的字符个数,一直操作到 \0 为止;长度受限制相反,我们可以限制操作的字符个数。

在使用的时候建议使用长度受限制的字符串函数,因为当目标空间不够的时候,我们进行字符串拷贝、追加会因为空间不够而造成出错。

5. 库函数 strcat 的使用

strcat : 字符串追加函数,专门用来追加字符串内容的函数。(将一段字符追加到目标空间)

strcat 的头文件

#include
#include

int main()
{
	char arr[20] = "hello ";
	strcat(arr, "world");
	printf("%s\n", arr);
	return 0;
}

代码的作用是将 world 追加到 arr 字符串的末尾。

 输出结果:

6. 如何模拟实现 strcat 

#include
#include

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest != '\0')
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr[20] = "hello ";
	my_strcat(arr, "world");
	printf("%s\n", arr);
	return 0;
}

一个参数依然是表示目标空间第二个参数表示源空间,代码的作用是将源空间的每一个字符都拷贝到目标空间,这和 strcpy 有些类似。

C语言中的字符与字符串函数一把梭_第4张图片

第一个循环为的是找到目标字符串的结尾,第二个循环为的是将源空间的字符拷贝到目标字符串的后面。 

三、长度受限制的字符串函数

1. strncpy - 长度受限制的字符串拷贝函数

 这个函数的参数有三个,前两个是要操作的字符串,第三个参数是你要拷贝多少个字节。

#include
#include

int main()
{
	char arr1[] = "hello";
	char arr2[] = "abcdefg";
	strncpy(arr1, arr2, 5);
	printf("%s", arr1);
	return 0;
}

arr1是目标空间, arr2是源空间,5是要拷贝的字节数,因为一个字符是一个字节;所以这段代码的含义是:将 arr2 数组的前5个字符拷贝到 arr1 数组中。

代码结果:

  

注意:当我们要拷贝的字节数大于源空间的字节数时,差几个字节就拷贝几个 '\0' 到目标空间去。

C语言中的字符与字符串函数一把梭_第5张图片

2.strncat - 长度受限制的字符串追加函数

这个函数的参数有三个,前两个是要操作的字符串,第三个参数是你要追加多少个字节。

#include
#include

int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";
	strncat(arr1, arr2, 5);
	printf("%s", arr1);
	return 0;
}

 代码结果:

arr1是目标空间, arr2是源空间,5是要追加的字节数,因为一个字符是一个字节;所以这段代码的含义是:将 arr2 数组的5个字符追加到 arr1 数组中。

注意: 值得注意的是在要追加的内容完成后还会追加一个 \0 ,因为补上一个 \0 才能是作为一个字符串存在。

C语言中的字符与字符串函数一把梭_第6张图片

 

注意:当我们要拷贝的字节数大于源空间的字节数时,不会像strcpy那样拷贝 \0 过去。 

3.strncmp - 长度受限制的字符串比较函数

 这个函数的参数也有三个,前两个是要比较的字符串,第三个参数是你要比较多少个字节。

#include
#include

int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "abcdf";
	int ret = strncmp(arr1, arr2, 5);
	if (ret > 0)
	{
		printf("arr1 > arr2");
	}
	else if (ret < 0)
	{
		printf("arr1 < arr2");
	}
	else
	{
		printf("arr1 == arr2");
	}
	return 0;
}

arr1是要比较的第一个字符串, arr2是要比较的第二个字符串,5是要比较的字节数,因为一个字符是一个字节;所以这段代码的含义是:比较 arr2 和 arr1 数组的前5个字符的大小。

代码结果:

四、字符串查找

strstr :是一个查找子串的函数,就是在一个字符串中查找了一个字符串存不存在。

1.strstr 如何使用呢?

        这个函数有两个参数,第一个参数是比较长的串,第二个是子串;函数的目的是要在这个比较长的串中查找子串是否存在。如果找到了子串会返回子串在长串的起始位置,找不到则返回一个空指针


#include
#include

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "cde";
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("子串不存在\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

子串如果存在,代码会打印从子串起始位置到 \0 的字符。

strstr 的头文件:

代码结果:

C语言中的字符与字符串函数一把梭_第7张图片

2.strstr 模拟实现

可能遇到的两种情况:

情况1

这一种情况是最简单的。

C语言中的字符与字符串函数一把梭_第8张图片

情况2

C语言中的字符与字符串函数一把梭_第9张图片

       值得注意的是,当s2全都对比过后还没有查找到,而且s1还有字符为对比过,则就要把s2重置到起始位置,把s1重置到第一次与s2相等的后面的字符,然后从这里开始对比,直到结束。 

代码实现:

#include
#include
#include

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* p = str1;
	const char* s1 = str1;
	const char* s2 = str2;
	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[] = "abcdefg";
	char arr2[] = "cde";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("子串不存在\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

3.strtok 字符串切割函数

字符串切割函数,把你想要的内容给切割出来。

这个函数有两个参数,返回类型是 char*

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

这一点是什么意思呢?

#include
#include
#include

int main()
{
	//假设是这个字符串:abcdefg@lilong.com
	char* sep = "@.";//@ 和 . 就是分隔符
	return 0;
}
  • 第一个参数指定一个字符串,它包含了 0 个或者多个由 sep 字符串中的一个或者多个分隔符分割的标记。
  • strtok函数找到str中的下一个,并蒋用大学结,的课指向这个标记的指针。 (注:strtok 函数会改变被操作的字符串,所以在使用 strtok 函数切分的字符串一般都是临时拷贝的内容并且可修改。)

这一点是什么意思呢?

C语言中的字符与字符串函数一把梭_第10张图片

 会返回 \0 之前的字符串。

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

头文件是

#include
#include

int main()
{
	//假设是这个字符串:abcdefg@lilong.com
	const char* sep = "@.";//@ 和 . 就是分隔符
	char str[] = "abcdefg@lilong.com";
	char cp[30] = { 0 };
	strcpy(cp, str);

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

代码结果:

C语言中的字符与字符串函数一把梭_第11张图片

五、错误信息报告

strerror :错误信息报告函数,返回错误码,所对应的信息。

函数的参数及返回类型

 

#include
#include
#include

//errno - 是C语言设置的一个全局的错误码存放的变量
int main()
{
    //"r" - 以读的形式打开 "test.txt" 这个文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		printf("%s\n", strerror(errno));
        //使用errno是需要引用头文件
		return 1;
	}
	else
	{
		printf("haha\n");
	}
	return 0;
}

 因为文件不存在,所以strerror 函数会返回一个错误信息。

代码结果:

C语言中的字符与字符串函数一把梭_第12张图片

六、字符操作

字符分类函数

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:任何可打印字符,包括图形字符和空白字符

因为这些函数使用起来比较简单,这里就不一一介绍了。大家可以去 cplusplus.com 这个网站查看;也可以使用 MSDN 来查看。

字符转换函数:

int tolower(int c);

int toupper(int c);

#include
#include

int main()
{
	printf("%c\n", tolower('A'));
    //将大写字母转化为小写
	return 0;
}

C语言中的字符与字符串函数一把梭_第13张图片

七、内存操作函数

1.memcpy内存拷贝函数如何使用呢?

memcpy:内存拷贝函数

        当不确定要拷贝内容的类型是什么的时候。可以把内存拷贝过去,这样不管是什么类型都可以拷贝。不用 strcpy 是因为它是字符串的拷贝函数,只能用来拷贝字符串。

 num 表示要拷贝多少个字节的内容,source 表示源空间,destination 表示目标空间。

#include
#include

int main()
{
	int src[] = { 1,2,3,4,5 };
	int dest[10] = { 0 };
	memcpy(dest, src, sizeof(src));
	return 0;
}

代码结果:C语言中的字符与字符串函数一把梭_第14张图片

 src 里的内容拷贝成功!

为什么这个函数的参数和返回类型是 void* 呢?

因为 void* 是一个泛型指针,它的通用高,当不确定是什么类型的时候使用它更加方便快捷。

2.模拟实现 memcpy

#include
#include

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	int src[] = { 5,6,7,8,9 };
	int dest[10] = { 0 };
	my_memcpy(dest, src, sizeof(src));
	return 0;
}

拷贝的数据是 int 类型的,但是这里为什么要使用 char* 来强制类型转换呢?

一个整形4个字节,如果强转为 int* 只能一次性拷贝4个字节,但如果要拷贝3个、11个或者是21个的(4的倍数)时候 int* 明显不合适,这个时候就可以使用最细致的 char* ,一次拷贝一个字节,通用型更强。

memcpy 是不用来处理重叠的内存之间的数据拷贝的

3.重叠内存之间的数据拷贝

memmove :也是一个内存拷贝函数,但是可以拷贝重叠内存之间的数据。

这是他的返回类型、参数和头文件

C语言中的字符与字符串函数一把梭_第15张图片值得注意的是它与 ,memcpy 的参数一样 。都是目标空间、源空间、和要拷贝的字节数。说明它的用法也是一样的。

下面的代码目的是将 1、2、3、4、5 拷贝到 3、4、5、6、7 上去,但是实际的结果是什么呢?

#include
#include

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

void test1()
{
	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
	int dest[20] = { 0 };
	my_memcpy(dest, src, 20);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", dest[i]);
	}
}

void test2()
{
	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memcpy(src + 2, src, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", src[i]);
	}
}

int main()
{
	test2();
	return 0;
}

代码结果:

如果拷贝成功了,代码的结果应该是:

1 2 1 2 3 4 5 8 9 10 

那为什么会出错呢?

是因为 memcpy 不能拷贝重叠内存之间的数据,要使用memmove来拷贝

C语言中的字符与字符串函数一把梭_第16张图片

memmove 库函数的使用方法:

#include
#include
#include

void test2()
{
	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(src + 2, src, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", src[i]);
	}
}

int main()
{
	test2();
	return 0;
}

代码结果:

这次拷贝成功了。 

4.memmove 模拟实现

在实现 memmove 会出现三种情况。

第一种:从前往后处理数据

C语言中的字符与字符串函数一把梭_第17张图片

 当 src 的起始地址在 dest 的起始地址左边的时候,就要采用从前往后处理数据的方式先拷贝4,最后拷贝8)来避免数据重叠而带来的错误。

第二种从后往前处理数据

C语言中的字符与字符串函数一把梭_第18张图片

 在 dest 的起始位置在 src 的范围内的时候,就要采用从后往前处理数据的方式先拷贝5,最后拷贝1)来避免数据重叠而带来的错误。

第三种:前往后,后往前任意

C语言中的字符与字符串函数一把梭_第19张图片

  在 dest 的起始位置不在 src 的范围内的时候,采用前往后,后往前任意

如果是第一种情况就采用 前往后,如果是第二、三两种情况就采用 后往前

代码实现:

#include
#include

void* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	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 test()
{
	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(src + 2, src, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", src[i]);
	}
}

int main()
{
	test();
	return 0;
}

5.内存比较

memcmp :内存比较函数

参数、返回类型和头文件:

C语言中的字符与字符串函数一把梭_第20张图片

buf1buf2 指向两块空间,count 表示向后在 count 个字节内部比较。

 如果要比较两块内存里的数据是否相同,就可以使用 memcmp

#include
#include

int main()
{
	int arr1[] = { 1,2,3 };
	int arr2[] = { 1,3,2 };
	int ret = memcmp(arr1, arr2, 12);
	printf("%d\n", ret);
	return 0;
}

C语言中的字符与字符串函数一把梭_第21张图片

如果第一块内存大于第二块内存,返回一个大于0的数字; 如果第一块内存等于第二块内存,返回数字0; 如果第一块内存小于第二块内存,返回一个小于0的数字; 

memcmp 也是一对一对比较的。

arr1:01 00 00 00 02 00 00 00 03 00 00 00
arr2:01 00 00 00 03 00 00 00 02 00 00 00

一对比可以很明显的看出 arr1 小于 arr2 ,所以返回小于0的数字。

代码结果:

C语言中的字符与字符串函数一把梭_第22张图片

注意:

  • memcmp 可以比较字符串也可以比较任意类型的数据。
  • memcmp 只有当参数中所有的字节都比较完后才会结束。

6.内存设置

memset :内存设置函数

参数、返回类型和头文件:

C语言中的字符与字符串函数一把梭_第23张图片

 如果有一份数据等待着对他初始化,就可以使用 memset

dest 参数是设置的填充空间,c 参数是要设置的值,count 参数是要设置的值的字节数

例1:

#include
#include

int main()
{
	char arr[] = "hello world";
	memset(arr, 'x', 5);
	printf("%s\n", arr);
	return 0;
}

代码的含义是将arr数组中的前5个字节的内容设置为字符x。

代码结果:

C语言中的字符与字符串函数一把梭_第24张图片

例2:

#include
#include

int main()
{
	char arr[] = "hello world";
	memset(arr + 6, 'x', 5);
	printf("%s\n", arr);
	return 0;
}

代码结果:

C语言中的字符与字符串函数一把梭_第25张图片

你可能感兴趣的