C语言：字符串函数、内存函数剖析

一、字符串函数

（一）求字符串长度

1、strlen

（1）库函数实现

strlen用来计算字符串的长度,遇到’\0’读取结束，这里‘\0’不算作长度。

size_t strlen ( const char * str );    
1

（2）自定义实现

自定义实现我们采取三种方式

//计数器实现
size_t my_strlen1(const char* str) {
	assert(str);
	int i = 0, count = 0;
	while (str[i]) {
		count += 1;
		i += 1;
	}
	return count;
}

//指针的实现
size_t my_strlen2(const char* str) {
	assert(str);
	const char* p = str;
	while (*p != '\0') p = p + 1;
	return p - str;
}

//递归的实现
size_t my_strlen3(const char* str) {
	assert(str);
	if (*str == '\0') return 0;
	else return my_strlen3(str + 1) + 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

1、strcpy

（1）库函数实现

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

strcpy用来将一个字符串复制到另一个字符串里面，包含’\0’。
目的空间要足够复制，不然程序会崩溃。

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

（2）自定义实现

这里while循环十分巧妙，既把’\0’复制进入destination，又结束循环
目的空间要足够复制，不然程序会崩溃。

char* my_strcpy(char* destination, const char* source) {
	assert(destination && source);
	char* ret;
	ret = destination;
	while (*destination++ = *source++) {
		;
	}
	return ret;
}
1
2
3
4
5
6
7
8
9

2、strcat

在目标字符串后面继续追加字符串
目的空间要足够复制，不然程序会崩溃。

（1）库函数实现

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

（2）自定义实现

目的空间要足够复制，不然程序会崩溃。

char* my_strcat(char* destination, const char* source) {
	assert(destination && source);
	char* ret = destination;
	while (*destination != '\0') destination += 1;
	while (*destination++ = *source++);
	return ret;
}
1
2
3
4
5
6
7

3、strcmp

strcmp用来比较两个字符串大小，C语言规定小于返回负数，大于返回负数，相等返回0。

（1）库函数实现

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

（2）自定义实现

int my_strcmp(const char* arr1, const char* arr2) {
	assert(arr1 && arr2);
	while (*arr1 == *arr2) {
		if (*arr1 == '\0') return 0;
		arr1++;
		arr2++;
	}
	if (*arr1 > *arr2) return 1;
	else return -1;
}

1
2
3
4
5
6
7
8
9
10
11

（三）长度受限制的字符串函数介绍

1、strncpy

相比于strcpy，添加了比较数量, 从souce复制几个到destination。

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

2、strncat

相比于strcat，添加了追加数量，从souce追加几个到destination。

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

3、strncmp

相比于strcmp，添加了比较数量。

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

（四）字符串查找

1、strstr

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

2、strtok

char * strtok ( char * str, const char * delimiters );
1

用来将一个字符串里面的信息分开。
第一个字符串不可以传const修饰的字符串常量

（五）错误信息报告

1、strerror

代码生产时会有一个全局变量errno（错误码）
strerror将错误码所对应的错误字符串的首字符返回。

char * strerror ( int errnum );
1

2、prerror

prerror函数是strerror的升级版，相当于printf + strerror

void perror ( const char * str );
1

二、内存操作函数

（一）内存拷贝

1、memcpy

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

按照字节拷贝

(1)库函数实现

(2)自定义实现

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;
}
1
2
3
4
5
6
7
8
9
10

2、memmove

相比于memcpy，可以针对重复内存的拷贝
按照字节拷贝

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

（1）库函数实现

和memcpy相似

（2）自定义实现

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（二）内存比较

1、memcmp

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

依次按字节来比较两个内存块大小

（三）内存设置

1、memset

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

（1）库函数实现

切记不可用来初始化设置整形数组中元素。如下，处理4个字节，就是一个整形空间

三、结束语

相信通过这篇文章，小伙伴们对字符串函数和内存函数的理解更加深刻了吧，记得给小编一个小小的赞哦！