常用的字符串+内存函数

简介

本文主要介绍一些常用函数的使用方法和模拟实现。

以下为主要介绍常用的一些字符串函数和内存函数。

种类	名称
字符串函数	strcat，strstr, strtok , strerror
内存函数	memcpy , memmove , memcmp

字符串函数

在介绍字符串函数中，会介绍例举的字符串函数使用方法和除strtok之外的字符串函数的模拟实现

strcat

1. 使用方法
   strcat作用是将一个字符串拷贝到另一个字符串的’\0’（包括’\0’）之后的位置，最后返回拷贝目标的起始位置的地址。我们例举一个例子：

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

int main()
{
	char arr1[10] = "abcd";
	char arr2[] = "abc";
	printf("%s", strcat(arr1, arr2));
	return 0;
}

结果为abcdabc，即将arr2的内容拷贝到arr1的末尾。

2. 模拟实现
   
   如图，strcat有两个指针变量的参数，简称为dest和src。dest即指向拷贝目标的起始位置的指针，src为指向拷贝内容的一个指针。为了避免不小心改变src指向的内容，因此用const修饰src指针。模拟实现如下：

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

第一个while先找’\0’,第二个while进行拷贝，最后返回起始位置的指针。

strstr

1. 使用方法
   该函数的作用是在一个字符串str1里找另一个字符串str2的内容，若能完整找到则返回str1里刚开始找到str2时的指针，不能则返回NULL空指针。
   例如：

	#include<string.h>
	#include<stdio.h>
	int main()
	{
		char ch1[] = "abcdefg";
		char ch2[] = "bcd";
		printf("%s", strstr(ch1, ch2));
		return 0;
	}

程序执行结果为 bcdefg

2. 模拟实现
   

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* ret = str1;
	while (*ret)
	{
		s1 = ret;
		s2 = str2;
		while (*s1 && *s2 && （*s1 == *s2）)
		{
			s1++;
			s2++;
			if (*s2 == '\0')
			{
				return ret;
			}
		}
		ret++;
	}
	return NULL;
}

为了在匹配失败后，可以知道原来的起始位置，例如我们在匹配前面部分字符相同时但后面不同，这时的指针指向改变了。为了便于记忆原来的起始位置，创建了新的指针变量s1和s2来代替str1和str2，从而不改变str1和str2的指向。
ret为每次匹配的起始位置，当一次匹配失败时，ret向前指向一位，当ret指向’\0’时，代表未能找到。

strtok

1. 使用方法

strtok有两个参数，我们将第一个参数称为str1,第二个参数称为str2.

• str2是个字符串，定义了用作分隔符的集合
• str1指向的字符串包含了0个或多个str2字符串中的分隔符
• strtok函数会将str1中的下一个分隔符，并将其用’\0’结尾 (注意，strtok会改变原来字符串的内容，因此我们最好对原来字符串进行拷贝，再针对拷贝的字符串进行操作） ，再返回这个位置的指针
• strtok的第一个参数不是NULL，strtok会找到str1里第一个分隔符，并保存它的位置
• strtok的第一个参数是NULL，strtok会从上次保存的位置开始，找下一个分隔符
• 若不存在下一个分隔符则返回NULL指针
• 例子：

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

int main()
{
	char str[] = "abc@def.ghi?jkl";
	char str1[30];
	strcpy(str1, str);//对原字符串进行拷贝
	char str2[] = "@.?";
	char* ret = NULL;
	for (strtok(ret = str1, str2); ret != NULL; ret = strtok(NULL, str2))
	{
		printf("%s\n",ret);
	}
	return 0;
}

结果：

strerror

1. 使用方法
   C语言的库函数在调用失败时，会将错误码放在一个叫：errno的变量中
   通过strerror 就可以将errno里的错误码转变成错误信息。
   例如，用fopen打开一个叫 ”untest.txt“ 的文件，若打开失败会返回NULL指针：

int main()
{
	FILE* pf;
	pf = fopen("untest.txt", "r");
	if (pf == NULL)
	{
		printf("错误信息: %s\n", strerror(errno));
	}
	return 0;
}

结果：

内存函数

前面的函数都是针对字符串进行操作，对于整型，结构体等变量，我们可以通过内存函数来进行操作

memcpy

1. 使用方法
   memcpy函数将从src的位置开始向后复制count个字节到dest起始的内存位置
   （注意，dest和src指向的尽量不要是同一个字符串里的内容。）
   例子：

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 11,12,13,14 };
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	int* p = memcpy(arr1, arr2, sizeof(arr2));
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);
	}
	printf("\n");
	return 0;
}

结果：

2. 模拟实现

void* my_memcpy(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;//返回起始位置
	while (count--)//循环次数为字节数量
	{
		//由于我们不知道变量大小，因此对每一个字节进行交换
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

memmove

memmove与memcpy的用法一样。但memmove可以用来处理源空间和目标空间出现重叠的情况。例如，当我们用memcpy对一个整形数组本身进行拷贝时：

1. 假设这个整形数组为：1，2，3，4，5，6，7，8
2. 我们要将1，2拷贝到2，3位置时，2先被1给覆盖了，此时2变成了1，再将1拷贝到3的位置的上
3. 最后可能出现的结果为 1，1，1，4，5，6，7，8

但是memmove可以解决这个问题，
我们来模拟实现memmove：

void* my_memmove(void* dest, void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	//第一种情况与memcpy模拟实现一样，我们将后面内容拷贝到前面
	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;
}

memcmp

memcmp函数从buf1和buf2两个指针开始比较count个字节。

• 一样大，返回0
• buf1指向的内容大，返回 >0 的数
• buf2指向的内容大，返回 <0 的数
  使用方法

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

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 1,2,3,4 };
	int arr3[] = { 1,2,3,5 };
	int arr4[] = { 1,2,3,3 };
	printf("%d\n", memcmp(arr1, arr2, 16));
	printf("%d\n", memcmp(arr1, arr3, 16));
	printf("%d\n", memcmp(arr1, arr4, 16));
	return 0;
}

结果：

当已经比较出大小，则不会比较后面数的大小，直接返回结果。