位置：首页-资讯-后端开发

深入了解C语言中的字符串和内存函数

2022-11-13 19:19

短信预约 -IT技能 免费直播动态提醒

1. 前言

大家好，我是努力学习游泳的鱼。今天我们来学习一些常用的库函数。有了这些库函数，我们可以更加方便地操作字符串和内存，从而提升我们的编码效率。话不多说，我们开始吧！

注：以下大部分函数对应的头文件都是string.h。

2. 求字符串长度

2.1 strlen

size_t strlen ( const char * str );

strlen函数可以求字符串的长度。使用时只需把字符串的起始位置的地址作为参数传递给strlen。该函数会从起始位置一直往后数字符，直到遇到\0。最终返回的是\0之前字符的个数。

参数指向的字符串必须以\0结束。否则求出来的是随机值。

返回类型是size_t，是无符号类型。

接下来使用三种方式来模拟实现strlen。

// 1. 使用计数器
size_t my_strlen(const char* str)
{
	int count = 0;
	assert(str != NULL);
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

// 2. 递归
size_t my_strlen(const char* str)
{
	assert(str != NULL);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

// 3. 指针-指针
size_t my_strlen(const char* str)
{
	assert(str != NULL);
	char* begin = str;
	// 找\0
	while (*str != '\0')
	{
		str++;
	}
	return str - begin;
}

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

3.1 strcpy

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

strcpy函数会把源字符串拷贝到目标空间中去。
源字符串必须以\0结束。
会将源字符串中的\0拷贝到目标空间。
目标空间必须足够大，以确保可以存放源字符串。
目标空间必须可变。
strcpy返回的是目标空间的起始地址。

接下来我们来模拟实现strcpy函数。

char* my_strcpy(char* dest, const char* class="lazy" data-src)
{
    char* ret = dest;
    assert(dest && class="lazy" data-src);
    while (*dest++ = *class="lazy" data-src++)
    {
        ;
    }
    return ret;
}

3.2 strcat

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

strcat会把源字符串追加到目标字符串后面。
源字符串必须以\0结束。
会把源字符串的\0拷贝到目标空间中去。
目标空间必须足够大，以确保可以存放源字符串。
目标空间必须可变。
strcat返回的是目标空间的起始地址。
不能自己给自己追加，因为当源字符串和目标空间重合时，会覆盖掉源字符串后面的\0。

有没有发现，其中很多点和strcpy很像？

接下来我们来模拟实现strcat。只需要两步：

找到目标空间的\0。
从目标空间的\0开始，把源字符串拷贝到目标空间中去。

char* my_strcat(char* dest, const char* class="lazy" data-src)
{
	assert(dest && class="lazy" data-src);
	char* ret = dest;

	// 找目标空间的\0
	while (*dest)
	{
		dest++;
	}
	// 从目标空间的\0开始，向后拷贝
	while (*dest++ = *class="lazy" data-src++)
	{
		;
	}

	return ret;
}

3.3 strcmp

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

strcmp函数比较的不是字符串的长度，而是比较字符串中对应位置上的字符的大小，如果相同，就比较下一对儿，直到不同或者都遇到\0。
若str1<str2，则返回值为负数；若str1>str2，则返回值为正数；若str1=str2，则返回值为0。

接下来我们来模拟实现strcmp。

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;
	}
}

4. 长度受限制的字符串函数

4.1 strncpy

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

拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串后，在目标的后面追加0，直到num个。

下面是strncpy的模拟实现。

char* my_strncpy(char* dest, const char* class="lazy" data-src, size_t count)
{
	assert(dest && class="lazy" data-src);
	char* start = dest;

	while (count && (*dest++ = *class="lazy" data-src++) != '\0')
	{
		count--;
	}

	if (count)
	{
		while (--count)
		{
			*dest++ = '\0';
		}
	}

	return start;
}

4.2 strncat

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

在目标空间后最多追加num个字符。
如果num大于源字符串的长度，则num直接看作源字符串的长度。
一定会在最后追加\0。

模拟实现如下：

char* my_strncat(char* front, const char* back, size_t count)
{
	assert(front && back);
	char* start = front;

	// 找front中的\0
	while (*front)
	{
		front++;
	}
	// 拷贝
	while (count--)
	{
		if ((*front++ = *back++) == '\0')
		{
			return start;
		}
	}

	*front = '\0';
	return start;
}

4.3 strncmp

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

只比较前num个字符。

以下是模拟实现：

int my_strncpy(const char* s1, const char* s2, size_t count)
{
	assert(s1 && s2);

	while (1)
	{
		if (count == 0)
		{
			return 0;
		}
		else if (*s1 > *s2)
		{
			return 1;
		}
		else if (*s1 < *s2)
		{
			return -1;
		}
		else
		{
			if (*s1 == '\0')
			{
				return 0;
			}
			s1++;
			s2++;
			count--;
		}
	}
}

5. 字符串查找

5.1 strstr

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

在str1中查找str2，如果找到了，就返回第一次出现的起始位置；如果找不到，就返回空指针NULL。

最简单的实现方式是直接暴力查找。

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);

	const char* s1 = str1;
	const char* s2 = str2;
	const char* cur = str1;

	while (*cur)
	{
		s1 = cur;
		s2 = str2;

		while (*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			// 找到了
			return (char*)cur;
		}

		cur++;
	}

	// 找不到
	return NULL;
}

5.2 strtok

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

strtok用于分割字符串。
sep是一个字符串，定义了用作分隔符的字符集合。
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用\0结尾，返回一个指向这个标记的指针。（注：strtok函数会改变该字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回NULL指针。

使用举例：

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

int main()
{
	char arr[] = "abc@def.123@456";
	char buf[30] = { 0 }; // 使用strtok，一般要做备份
	strcpy(buf, arr);
	const char* sep = "@."; // 分隔符的集合

	char* str = NULL;
	for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}

	return 0;
}

6. 错误信息报告

6.1 strerror

char * strerror ( int errnum );

会返回错误码对应的错误信息。

有一个全局变量errno，会记录库函数在调用失败后的错误码。使用时需要引用头文件errno.h。

使用举例：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <errno.h>

int main()
{
	int* p = (int*)malloc(INT_MAX);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}

	return 0;
}

7. 字符操作函数

以下函数对应的头文件是ctype.h。

7.1 字符分类函数

函数	如果它的参数复合下列条件就返回真
iscntrl	任何控制字符
isspace	任何空白字符
isdigit	十进制数字
isxdigit	十六进制数字
islower	小写字母
isupper	大写字母
isalpha	大小写字母
isalnum	大小写字母或数字
ispunct	标点符号
isgraph	图形字符
isprint	可打印字符

7.2 字符转换函数

转小写：

int tolower( int c );

转大写

int toupper( int c );

8. 内存操作函数

8.1 memcpy

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

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

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

如果source和destination有任何的重叠，复制的结果都是未定义的。

模拟实现如下：

void* my_memcpy(void* dest, const void* class="lazy" data-src, size_t count)
{
	assert(dest && class="lazy" data-src);
	void* ret = dest;

	while (count--)
	{
		*(char*)dest = *(char*)class="lazy" data-src;
		dest = (char*)dest + 1;
		class="lazy" data-src = (char*)class="lazy" data-src + 1;
	}

	return ret;
}

8.2 memmove

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

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

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

模拟实现如下：

void* my_memmove(void* dest, const void* class="lazy" data-src, size_t count)
{
	assert(dest && class="lazy" data-src);
	void* ret = dest;

	if (dest < class="lazy" data-src)
	{
		// 前->后
		while (count--)
		{
			*(char*)dest = *(char*)class="lazy" data-src;
			dest = (char*)dest + 1;
			class="lazy" data-src = (char*)class="lazy" data-src + 1;
		}
	}
	else
	{
		// 后->前
		while (count--)
		{
			*((char*)dest + count) = *((char*)class="lazy" data-src + count);
		}
	}

	return ret;
}

8.3 memcmp

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

比较从ptr1和ptr2指针开始的num个字节。

返回值和strcmp类似，根据大小关系返回正数、负数或者0。

模拟实现如下：

int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
	assert(ptr1 && ptr2);

	while (num--)
	{
		if (*(char*)ptr1 > *(char*)ptr2)
		{
			return 1;
		}
		else if (*(char*)ptr1 < *(char*)ptr2)
		{
			return -1;
		}
		ptr1 = (char*)ptr1 + 1;
		ptr2 = (char*)ptr2 + 1;
	}

	return 0;
}

以上就是深入了解C语言中的字符串和内存函数的详细内容，更多关于C语言字符串内存函数的资料请关注编程网其它相关文章！

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

C语言字符串内存函数 C语言字符串 C语言内存函数

阅读原文内容投诉