字符串函数和内存函数的介绍

半只牛马

已于 2023-10-29 23:40:00 修改

阅读量85

点赞数 2

分类专栏： C语言文章标签： c语言开发语言

于 2023-02-13 14:05:37 首次发布

本文链接：https://blog.csdn.net/weixin_68624665/article/details/128944094

版权

C语言专栏收录该内容

18 篇文章 0 订阅

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

今天小编给大家带来的是常用的字符串函数和内存函数的介绍以及它们中的部分函数的模拟实现，希望大家跟着小编的步伐，对这些函数的用法和逻辑有个大概的理解。

1.strlen函数

strlen函数的作用是得到字符串的长度.

size_t strlen ( const char *str );这里给出strlen函数的返回值和形式参数。以下有几点是大家需要注意的

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

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

3.函数的返回值为size_t，是无符号的（因为长度是不会出现负数的，所以我们这里使用无符号数）

使用演示:

#include<stdio.h>
#include<string>//使用strlen函数前要包含该头文件
int main()
{
 char arr[]="abcdefg";
 int ret=strlen(arr);
 printf("%d",ret);
 return 0;
}

代码结果：7

函数模拟实现：

对于strlen函数这里有三种模拟方法这里给大家介绍两种（还有一种我们放在指针的介绍中给大家说明）

#include<stdio.h>
#include<assert.h>
//strlen函数的模拟实现
//法一：
size_t my_strlen1(const char* str)
{
	assert(str != NULL);
	size_t count = 0;
	while (*str != '\0')
	{	
		count++;
		str++;
    }
	return count;
}
//法二：递归
size_t my_strlen2(const char* str)
{
	assert(str != NULL);
	if (*str != '\0')
	{
		return 1 + my_strlen2(str + 1);
	}
	else
		return 0;
}
int main()
{
	char arr[] = "abcdefghi";
	int ret = my_strlen1(arr);
	int ret1= my_strlen2(arr);
	printf("%d %d ", ret,ret1);
	return 0;
}

结果如下：

2.strcpy

strcpy函数的作用是将源字符串复制到目标字符串的作用，下面给出该返回值和形式参数

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

这里source表示的是源字符串，destination表示的是目标字符串，该返回值返回的是目标字符串的地址来让我们使用。以下这里还有几点我需要说明

1.源字符串必须以 '\0' 结束。

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

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

4.目标空间必须可变。(常量字符串不可修改)

对于第四点相信大家可能不是很理解，这里我用代码给大家解释一下

这里代码发生了错误，该原因就是由于常量字符串是不可修改的，所以该不能作为目标空间。

但是如果该字符作为源字符串，这里就是可以使用的，演示如下

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>//使用strcpy函数前要包含该头文件
int main()
{
	char arr[20] = { 0 };
	char* p = "abcdefg";
	printf("%s ",strcpy(arr, p));
	return 0;
}

结果：

函数模拟实现：

#include<stdio.h>
#include<assert.h>
//strcpy函数的模拟实现
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest++ = *src++)//这里的是先进行解引用然后再进行指针后移，当*dest==*src=='\0'后结束
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "xxxxxxxxxxxx";
	char arr2[] = "hello world";
	printf("%s ", my_strcpy(arr1, arr2));
	return 0;
}

代码结果如下：

3.strcat

strcat函数的作用是实现字符串的追加，该返回值和形式参数如下

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

该是将source表示的源字符串追加到destination的目标字符串中，返回的是目标字符串的地址

注意：

1.源字符串必须以 '\0' 结束。

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

3.目标空间必须可修改。

4.目标空间必须有\0

使用如下：

#include<stdio.h>
#include<string.h>//使用strcat函数前要包含该头文件
int main()
{
	char arr[20] = "abc";
	char arr1[20]= "abcdefg";
	printf("%s ",strcat(arr, arr1));
	return 0;
}

结果展示：

模拟函数：

#include<stdio.h>
#include<assert.h>
//strcat函数的模拟实现
char* my_strcat(char* dest, char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest != '\0')
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
} 
int main()
{
	char arr1[20] = "hello";
	char arr2[] = " world";
	printf("%s", my_strcat(arr1, arr2));
	return 0;
}

结果如下：

4.strcmp

strcmp函数的作用是进行字符串的比较，该返回值和形参如下

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

标准规定：

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

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

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

另外对于strcmp函数的使用字符串的比较方式是比较对应位置的ASCLL码值。

使用方式如下

#include<stdio.h>
#include<string.h>//使用strcmp函数前要包含该头文件
int main()
{
	char arr[20] = "abc";
	char arr1[20]= "abcdefg";
	printf("%d",strcmp(arr, arr1));
	return 0;
}

结果如下：

模拟实现：

#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 arr1[] = "abbc";
	char arr2[] = "accs";
	int ret = my_strcmp(arr1, arr2);
	printf("%d", ret);
	return 0;
}

结果如下：

以上strcpy,strcat,strcmp这三种是长度不受限度的字符串函数，即一直会\0停止，这就导致这三种字符串函数不安全（有着非法访问的风险），这就导致C语言引入了长度受限制的字符串函数strncpy,strncat,strncmp。（由于该三个函数的用法和模拟思路和以上大同小异，这里我们就不进行使用和模拟，大家可以自己进行尝试）

5.strncpy

strncpy函数和strcpy函数的区别是strncpy可以指定源字符串复制到目标字符串的元素个数，

该返回值和形参如下：

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

num表示的是从source中指定拷贝几个元素

如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加\0，直到num个该函数在拷贝过程中，如果source中拷贝的个数少于source的大小，当数据拷贝到destination中后，后面不会自动添加/0

6.,strncat

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

num表示的是从source中指定追加几个字符，在追加后该会自动给字符串destination添加\0

7.strncmp

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

num表示的是指定比较几个字符，该返回值的规定和strcmp的规定一致

8.strstr

strstr函数的作用是在字符串中寻找子串，对于该返回值和形参如下

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

这里表示的是在str1字符串中寻找子串str2，对于该返回值，规定如下

使用方式如下

#include <stdio.h>
#include <string.h>
int main()
{
	char str[] = "This is a simple string";
	char* pch;
	pch = strstr(str, "simple");
	puts(pch);
	return 0;
}

结果展示：

函数模拟实现：

#include<stdio.h>
#include<assert.h>
//strstr函数的模拟实现
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	if (*str2 == '\0')//如果子串为空指针，直接返回主串
	{
		return str1;
	}
	const char* s1 = str1;//这里的s1和s2指针分别用于主串和子串的元素访问
	const char* s2 = str2;
	const char* cp = str1;//cp是记录主串每次访问的位置
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return cp;
		}
		if (*s1 == '\0')
		{
			return NULL;
		}//经过以上循环，判断s1和s2的内容来决定返回值
		cp++;
	}//以上，首先是使用s1访问主串，如果没有匹配到子串，这时就需要cp到主串下一个位置，此时s2返回至
//子窜的首元素位置
}
int main()
{
	char arr[] = "abbbcdd";
	char arr1[] = "bbc";
	printf("%s ", my_strstr(arr, arr1));
	return 0;
}

对于子串的寻找，我们需要学习的有两种，第一种BF算法和KMP算法，对于KMP算法，我会在介绍数据结构的内容中给大家展现，今天给大家介绍的是第一种算法，也可以理解为暴力枚举。

9.strtok

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

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

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

记。

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

strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容

并且可修改。）

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

中的位置。

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

记。

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

使用展示：

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

int main()
{
    char str[] = "This a, sample string.";
    char* pch;
    pch = strtok(str, ",.-");
    while (pch != NULL)
    {
        printf("%s\n", pch);
        pch = strtok(NULL, " ,.-");
    }
    return 0;
}

结果展示：

10.strerror

char * strerror ( int errnum )；

（返回错误码所对应的错误信息）（头文件是stdio.h）

C语言的库函数在运行的时候，如果发生错误，就会将一个错误码存在一个变量中，这个变量是个全局变量是：errno，如果要在strerror函数使用全局变量errno的话需要包含头文件（errno.h）

错误码是一些数字，我们就需要将错误码翻译成错误信息,该函数就是给errnum一个错误码，该函数返回错误信息的起始地址

使用展示：

#include <stdio.h>
#include <string.h>
#include <errno.h>//必须包含的头文件
int main ()
{ FILE * pFile;
  pFile = fopen ("text.txt","r");
  if (pFile == NULL)
    printf ("%s\n",strerror(errno));
  return 0;
}

结果展示：

11.memcpy

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

内存拷贝，可以接受任意类型，num表示接收的字节数，可以用num决定拷贝元素的个数

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

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

如果source和destination有任何的重叠，复制的结果都是未定义的，在某些平台不能实现重叠拷贝

使用展示：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "acbyg";
	char arr1[20] = { 0 };
	printf("%s", memcpy(arr1,arr,5));
	return 0;
}

结果展示：

模拟实现：

#include<stdio.h>
#include<assert.h>
//memcpy函数的模拟实现
void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	while (num--)
	{
		*(char*)dest = *(char*)src;
		//不能放在后置++，因为强制类型转换是临时的
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
    return ret;
}
int main()
{
	const char arr1[] = "abcdefg";
	char arr2[10] = { 0 };
	my_memcpy(arr2, arr1,7);
	printf("%s", arr2);
	return 0;
}

结果展示：

12.memmove

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

该和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

如果源空间和目标空间出现重叠，就得使用memmove函数处理

使用展示:

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

结果展示：

这里我们在同一个数组中出现了内容重叠，如果不使用memmove按理论上讲，该应该出现的情况理应是:

那么对于memmove函数，在出现内容重叠时，我们就需要进行判断，接下来看代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//menmove函数的模拟实现
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;
}

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

对于出现重叠时，我们分两种情况，1，当dest<src时，此时为了防止数据被覆盖，我们可以重src的首元素开始向后逐步复制

2.当src<dest时，出现了数据覆盖时，我们可以让src重最末尾需要复制的元素开始进行复制。

除此之外我们可以随意采用那种方式进行复制。

结果如下：

13.mencmp

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

比较从ptr1和ptr2指针开始的num个字节，一个字节一个字节进行比较

返回值如下

使用展示：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "abcc";
	char arr2[] = "aaaa";
	int ret = memcmp(arr1, arr2, 4);
	printf("%d", ret);
	return 0;
}

结果展示：