C语言 ＜string.h＞ 常用库函数一览（上）

最新推荐文章于 2024-08-24 16:33:47 发布
最新推荐文章于 2024-08-24 16:33:47 发布
阅读量900 收藏 7
点赞数 2
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_70793373/article/details/127036755
版权

本篇介绍C语言提供的这些库函数：内存块和字符串的拷贝，字符串连接、内存块和字符串比较

文章目录

一、Copy

1. memcpy

memcpy

函数原型： void * memcpy ( void * destination, const void * source, size_t num );

函数功能：从 source 指向的内存空间拷贝 num 个字节的内容到 destination 指向的内存空间

  • 函数可以拷贝任意类型的数据
  • 函数会精确的拷贝 num 个字节，应该保证目标空间大于等于 num 个字节
  • 当内存重叠时建议使用 memmove

参数列表：

  • destination：拷贝目标起始空间的地址
  • source：拷贝源头起始空间的地址
    const ：函数中 source 指向的空间内容不应该被修改
  • num：拷贝的字节数
    size_t ：unsigned int 的重命名

返回值：destination 的起始地址
接收返回值，转化为特定类型后，可以实现链式访问等

例子：

#include <stdio.h>

//打印数组内容
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int arr_copy[5] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("拷贝前：");
	print(arr_copy, sz);

	//拷贝 arr数组的前 12 个字节（3 个整形）到 arr_copy 数组中
	memcpy(arr_copy, arr, 12);
	printf("拷贝后：");
	print(arr_copy, sz);

	return 0;
}

输出：
拷贝前：0 0 0 0 0
拷贝后：1 2 3 0 0

memcpy 的模拟实现:

void* 类型的指针可以接收任意类型的地址，但 void* 的指针却不能进行整数加减，以及间接访问操作，所以这里强转为 char* 后逐字节拷贝即可

#include <assert.h>

void* my_memcpy(void* dest, void* src, int num)
{
	//需要对指针进行间接访问，指针不能为空指针
	assert(dest != NULL && src != NULL);

	void* ret = dest;	
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}

	return ret;
}

2. memmove

memmove

函数原型：void * memmove ( void * destination, const void * source, size_t num );

函数功能、参数列表、返回值与 memcpy 相同，点击即可跳转，但 memmove 可以实现重叠内存拷贝

例子：

#include <stdio.h>

//打印数组
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	printf("移动前：");
	print(arr, sz);

	//重叠拷贝：
	//将数组 arr 中的 3 4 5 6 7 拷贝到数组 arr 中 5 6 7 8 9 的位置
	memmove(arr + 4, arr + 2, 20);
	printf("移动后：");
	print(arr, sz);

	return 0;
}

输出：
移动前：1 2 3 4 5 6 7 8 9 10
移动后：1 2 3 4 3 4 5 6 7 10

memmove 模拟实现：

与 memcpy 的模拟实现相同：需要转换为 char* 指针进行操作
对于重叠拷贝的内存做出如下分析
在这里插入图片描述

#include <assert.h>

void* my_memmove(void* dest, void* src, int num)
{
	//需要对指针进行间接访问，指针不能为空指针
	assert(dest != NULL && src != NULL);

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

3. strcpy

strcpy

函数原型：char * strcpy ( char * destination, const char * source );

函数功能：将 source 指向的字符串拷贝到 destination 指向的字符数组中

函数拷贝时遇到 source 的 ‘\0’ 时拷贝结束，‘\0’ 也会拷贝到 destination 指向的数组中

  • source 指向的字符串需要包含 ‘\0’
  • 目标空间足够大，能保证可以容纳拷贝的字符串以及 ‘\0’
  • 重叠拷贝请使用 memmove

参数列表：

  • destination：指向拷贝到的目标数组的起始地址
  • source：指向拷贝源头的字符串起始地址
    const ：函数中 source 指向的字符串不应该被修改

返回值：destination 的起始地址
将返回值作为其他函数的参数，可以实现链式访问等

例子：

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

int main()
{
	char arr[20] = "Hello!";
	char* p = "Hello reader!";

	//拷贝前
	printf("%s\n", arr);

	//拷贝后
	strcpy(arr, p);
	printf("%s\n", arr);

	return 0;
}

输出：
Hello!
Hello reader!

strcpy 模拟实现：

逐字节拷贝即可，遇到 '\0’时停止
注意：‘\0’ 也需要拷贝

#include <assert.h>

char* my_strcpy(char* dest, const char* src)
{
	//需要对指针进行间接访问，指针不能为空指针
	assert(dest != NULL && src != NULL);

	//'\0' ASCII码为 0，可以做为循环的结束条件
	char* ret = dest;
	while (*dest++ = *src++)
		;

	return ret;
}

4. strncpy

strncpy

函数原型：char * strncpy ( char * destination, const char * source, size_t num );

函数功能：拷贝 source 指向的字符串中前 num 个字符到 destination 指向的字符数组中

source 指向的字符串不足 num 个字符时，以 ‘\0’ 补充

  • 目标空间足够大，能保证可以容纳拷贝的 n 个字符
  • 拷贝 num 个字符之后，不会主动加上 ‘\0’
  • 重叠拷贝请使用 memmove

参数列表：

  • destination：指向拷贝目标数组的起始地址
  • source：指向拷贝源头的字符串起始地址
    const ：函数中 source 指向的字符串不应该被修改
  • num：拷贝的字节个数
    size_t ：unsigned int 的重命名

返回值：destination 的起始地址
将返回值做为其他函数参数，可以实现链式访问

例子：

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

int main()
{
	char arr[20] = "Hello! Hello!";
	char* p = "reader";

	//拷贝前
	printf("%s\n", arr);
	
	//拷贝后
	strncpy(arr, p, 6);
	printf("%s\n", arr);

	return 0;
}

输出：
Hello! Hello!
reader Hello!

strncpy 模拟实现：

拷贝 num 个字节，不足以 ‘\0’ 补充

#include <assert.h>

char* my_strncpy(char* dest, const char* src, int num)
{
	//需要对指针进行间接访问，指针不能为空指针
	assert(dest != NULL && src != NULL);

	char* ret = dest;
	while (num && (*dest++ = *src++))
		num--;

	while (num--)
		*dest++ = '\0';

	return ret;
}

二、Concatenation

1. strcat

strcat

函数原型：char * strcat ( char * destination, const char * source );

函数功能：source 指向的字符串追加到 destination 字符数组之后

从 destination 字符数组中的 ‘\0’ 开始追加，追加到 source 指向的字符串遇到 ‘\0’ 时停止

参数列表：

  • destination：指向追加到的目标数组的起始地址
  • source：指向追加源头的字符串起始地址
    const ：函数中 source 指向的字符串不应该被修改

返回值：destination 的起始地址
将返回值做为其他函数参数，可以实现链式访问

例子：

#include <string.h>

int main()
{
	char arr[20] = "Hello ";
	char* p = "readers!";

	//追加前
	printf("%s\n", arr);

	//追加后
	strcat(arr, p);
	printf("%s\n", arr);

	return 0;
}

输出：
Hello
Hello readers!

strcat 模拟实现：

先找到 destination 字符数组中的 ‘\0’，然后与 strcpy 模拟实现相同
逐字节拷贝，遇到 '\0’时停止 ‘\0’ 也需要拷贝

#include <assert.h>

char* my_strcat(char* dest, const char* src)
{
	//需要对指针进行间接访问，指针不能为空指针
	assert(dest != NULL && src != NULL);

	char* ret = dest;
	while (*dest != '\0')
		dest++;

	//'\0' ASCII码为 0，可以做为循环的结束条件
	while (*dest++ = *src++)
		;

	return ret;
}

2. strncat

strncat

函数原型：char * strncat ( char * destination, const char * source, size_t num );

函数功能：source 指向的字符串前 num 个字符追加到 destination 字符数组之后

从 destination 字符数组中的 ‘\0’ 开始追加
source 指向的字符串长度大于 num 则追加 num 个字符后，加上 ‘\0’
小于 num 则追加到 source 指向的字符串 ‘\0’ 处

参数列表：

  • destination：指向追加目标数组的起始地址
  • source：指向追加源头字符串的起始地址
    const ：函数中 source 指向的字符串不应该被修改
  • num：追加的字节个数
    size_t ：unsigned int 的重命名

返回值：destination 的起始地址
将返回值做为其他函数参数，可以实现链式访问

例子：

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

int main()
{
	char arr[20] = "Hello! ";
	
	//追加前
	printf("%s\n", arr);

	//追击后
	strncat(arr, arr, 6);
	printf("%s\n", arr);

	return 0;
}

输出：
Hello!
Hello! Hello!

strncat 模拟实现：

先找到 destination 字符数组中的 ‘\0’，然后与 strncpy 模拟实现相似
注意：追加 num 个字节，未超时不处理，超过时末尾需要加上 ‘\0’ 

#include <assert.h>

char* my_strncat(char* dest, const char* src, int num)
{
	//需要对指针进行间接访问，指针不能为空指针
	assert(dest != NULL && src != NULL);

	char* ret = dest;
	while (*dest != '\0')
		dest++;

	while (num && (*dest++ = *src++))
		num--;

	*dest = '\0';

	return ret;
}

三、Comparison

1. memcmp

memcmp

函数原型：int memcmp ( const void * ptr1, const void * ptr2, size_t num );

函数功能：ptr1 指向的内存块前 num 个字节内容和 ptr2 指向的内存块前 num 个字节内容比较

可以比较任意类型的数据
从第一个字节内容开始比较，相等比较下一个字节内容

  • 如果 ptr1 指向的字节内容大于 ptr2 指向的字节内容，返回大于 0 的数字
  • ptr1 指向的字节内容小于 ptr2 指向的字节内容，返回小于 0 的数字
  • 比较的 num 个字节内容都相等时返回 0

参数列表：

  • ptr1 指向比较的内存块
    const ：函数中 ptr1 指向的内存块内容不应该被修改
  • ptr2 指向比较的内存块
    const ：函数中 ptr2 指向的内存块内容不应该被修改
  • num：比较的字节个数
    size_t ：unsigned int 的重命名

返回值：

  • ptr1 大于 ptr2 返回大于 0 的数字
  • ptr1 等于 ptr2 返回等于 0 的数字
  • ptr1 小于 ptr2 返回小于 0 的数字

例子：

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

int main()
{
	int arr1[5] = { 1,2,3,4,4 };
	int arr2[5] = { 1,2,3,4,5 };
	
	int arr3[5] = { 1,2,3,4,5 };
	int arr4[5] = { 1,2,3,4,5 };

	int arr5[5] = { 1,2,3,4,5 };
	int arr6[5] = { 1,2,3,5,5 };

	printf("%d\n", memcmp(arr1, arr2, 20));
	printf("%d\n", memcmp(arr3, arr4, 20));
	printf("%d\n", memcmp(arr5, arr6, 20));

	return 0;
}

输出结果：
-1
0
-1

memcmp 模拟实现：

void* 类型的指针可以接收任意类型的地址，但 void* 的指针却不能进行整数加减，以及间接访问操作，所以这里强转为 char* 后逐字节内容比较即可

#include <assert.h>

int my_memcmp(const void* ptr1, const void* ptr2, int num)
{
	//需要对指针进行间接访问，指针不能为空指针
	assert(ptr1 != NULL && ptr2 != NULL);

	while (num && (*(char*)ptr1 == *(char*)ptr2))
	{
		ptr1 = (char*)ptr1 + 1;
		ptr2 = (char*)ptr2 + 1;
		num--;
	}

	if (num == 0)
		return 0;
	else
		return *(char*)ptr1 - *(char*)ptr2;
}

2. strcmp

strcmp

函数原型：int strcmp ( const char * str1, const char * str2 );

函数功能：str1 指向的字符串和 str2 指向的字符串比较

从第一个字符开始比较，相等则比较下一个字符

  • 如果 str1 指向的字符大于 str2 指向的字符，返回大于 0 的数字
  • str1 指向的字符小于 str2 指向的字符，返回小于 0 的数字
  • str1 和 str2 都指向 ‘\0’ 时，返回0

参数列表：

  • str1 指向比较的字符串
    const ：函数中 str1 指向的字符串不应该被修改
  • str2 指向比较的字符串
    const ：函数中 str2 指向的字符串不应该被修改

返回值：

  • str1 大于 str2 返回大于 0 的数字
  • str1 等于 str2 返回等于 0 的数字
  • str1 小于 str2 返回小于 0 的数字

例子：

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

int main()
{
	char* p1 = "good";
	char* p2 = "gooD";
	
	char* p3 = "good";
	char* p4 = "good";

	char* p5 = "gooD";
	char* p6 = "good";

	printf("%d\n", strcmp(p1, p2));
	printf("%d\n", strcmp(p3, p4));
	printf("%d\n", strcmp(p5, p6));

	return 0;
}

输出结果：
-1
0
-1

strcmp 模拟实现：

逐字符比较即可

#include <assert.h>

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 != NULL && str2 != NULL);

	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;

		str1++;
		str2++;
	}

	return *str1 - *str2;
}

3. strncmp

strncmp

函数原型：int strncmp(const char* str1, const char* str2, size_t num);

函数功能：str1 指向的字符串前 num 个字符和 str2 指向的字符串前 num 个字符比较

从第一个字符开始比较，相等比较下一个字符

  • 如果 ptr1 指向的字符大于 ptr2 指向的字符，返回大于 0 的数字
  • ptr1 指向的字符小于 ptr2 指向的字符，返回小于 0 的数字
  • 比较的 num 个字符都相等时 返回 0

参数列表：

  • str1 指向比较的字符串
    const ：函数中 str1 指向的字符串不应该被修改
  • str2 指向比较的字符串
    const ：函数中 str2 指向的字符串不应该被修改
  • num：比较的字符个数
    size_t ：unsigned int 的重命名

返回值：

  • ptr1 大于 ptr2 返回大于 0 的数字
  • ptr1 等于 ptr2 返回等于 0 的数字
  • ptr1 小于 ptr2 返回小于 0 的数字

例子：

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

int main()
{
	char* p1 = "HeLLo!";
	char* p2 = "HEllo!";

	char* p3 = "HeLLO!";
	char* p4 = "Hello!";

	char* p5 = "HELLO!";
	char* p6 = "Hello!";

	printf("%d\n", strncmp(p1, p2, 2));
	printf("%d\n", strncmp(p3, p4, 2));
	printf("%d\n", strncmp(p5, p6, 2));

	return 0;
}

输出
-1
0
-1

strncmp 模拟实现：

逐字符比较
若中途 str1 指针和 str2 指针都遇到 ‘\0’ 时也表示字符串相等


#include <assert.h>

int my_strncmp(const char* str1, const char* str2, int num)
{
	assert(str1 != NULL && str2 != NULL);

	while (num && *str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;

		str1++;
		str2++;
		num--;
	}

	if (num == 0)
		return 0;
	else
		return *str1 - *str2;
}
[Pokemon]大猫猫
关注
专栏目录
Linux系统编程
qq_45769467的博客
02-04 1172
第六天 程序和进程 1、程序 是指编译好的二进制文件，在磁盘上，不占用系统资源，包括CPU、内存、打开的文件、设备、锁等等 2、进程 是一个抽象的概念，与操作系统原理联系紧密。进程是高度活跃的程序，占用系统资源。在内存中执行。（程序运行起来就产生一个进程） 并发 在操作系统中，一个时间段中有多个进程都处于已启动运行到运行完毕之间的状态，但在任意一个时间点上，仍然只有一个进程在运行。例如：计算机...
C语言库函数源码（string.h）
04-12
里面包含大多数的C语言库函数源码，其中string.h中的源码最为多，希望能对大家有所帮助。
C语言中String库函数
nankong的专栏
10-16 1588
 为了以后学习以及查阅方便，转贴在此，若有雷同，敬请包含。文中内容摘自《C程序设计教程》（美）H.M.Deitel P.J.Deitel著，薛万鹏等译，机械工业出版社。 void *memccpy (void *dest, const void *src, int c, size_t n); 从src所指向的对象复制n个字符到dest所指向的对象中。如果复制过程中遇到了字
string的常用函数
最新发布
be_a_big_cattle的博客
08-24 704
擦除字符串的内容，该字符串将变为空字符串（长度为 0 个字符）。而cin>> 遇到空格（' '）就会停止输入。请求根据计划的大小更改调整空间的大小。在pos 位置 插入 字符 或 字符串。请求更改容量（capacity）可以参考返回值，判断是否相同。直到遇到 ‘\n’ 才会停止。rbegin 指向尾。计算分配的空间的大小。都是增加字符串的函数。
《C prime plus (第五版）》 ---第11章 字符串和字符串函数---3
weixin_30500105的博客
12-18 181
字符串函数总结： 下面是头文件 string.h 中定义的函数： 序号函数 & 描述 1 void *memchr(const void *str, int c, size_t n)在参数str所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。 2 int memcmp(const void *str1, ...
C语言中的String库函数
静思阁
12-10 1334
// Published August 8th, 2006 in C/C++. //以下内容摘自《C程序设计教程》（美）H.M.Deitel P.J.Deitel著，薛万鹏等译，机械工业出版社。void *memccpy (void *dest, const void *src, int c, size_t n);//从src所指向的对象复制n个字符到dest所指向的对象中。如果复制过程中遇到了字
C语言string库函数介绍(附模拟实现)
The_west18的博客
01-26 8939
strlen strcpy strcat strcmp strncpy strncat strncpy strstr strtok strerror memcpy memmove memset memcmp
C++常用头文件详解：一站式包含列表
13. `<string.h>`: 字符串处理函数，如`strlen()`、`strcpy()`等。 14. `<strstream.h>`: 古老的字符串流处理，已被`<sstream>`替代。 15. `<time.h>`: 时间和日期处理，包括时间结构、函数和格式化。 16. `...
C与C++头文件一览.doc
01-31
- **`<stdlib.h>`**：包含了一些常用的杂项函数，例如 `malloc`, `free` 等。 - **`<string.h>`**：提供了一系列字符串操作函数，如 `strcpy`, `strcat` 等。 - **`<time.h>`**：定义了一系列处理日期和时间的函数，...
C函数一览表.rar_文章/文档_C/C++_
08-09
1. **标准库函数**：如<stdio.h>中的printf()和scanf()用于输入输出，<stdlib.h>中的malloc()和free()进行动态内存分配与释放，<string.h>中的strcpy()和strlen()处理字符串。 2. **控制流函数**：如if语句、switch...
C C++头文件一览
11-30
`<string.h>` 提供了字符串处理函数，如`strcpy()`, `strcat()`, `strlen()`等，用于字符串操作。 #### 13. `<strstrea.h>` 提供了基于数组的输入/输出流，允许将数组视为输入输出流来处理。 #### 14. `<time.h>`...
2024年C标准库——string(1)，2024年最新细谈分布式事务的前世今生
2401_85011985的博客
05-14 870
includeint main()/* null character manually added */ //调试过程提示用strncpy_s 更安全puts(str1);puts(str2);puts(str3);return 0;#includeint main()*/ //使用跟安全的函数puts(str);return 0;#include。
C语言——简单实现string库中基础函数（strcpy、strncpy、strcmp、strncmp、strcat、strstr、strch、strtok）
m0_64036274的博客
11-28 846
简单实现string库中基础函数（strcpy、strncpy、strcmp、strncmp、strcat、strstr、strch、strtok）
C语言string库之常用字符和字符串函数详解
B1ue还在专注
07-14 2473
1、求字符串长度strlen->求出字符串到 \0 前的字符的数量2、长度不受限制的字符串函数strcpy->将源地址到结束符 \0 的字符都复制到目标地址中strcat->将源字符串的副本追加到目标字符串后面strcmp->比较两个字符串 第一个字符串大于第二个字符串，则返回大于0的数字，第一个字符串等于第二个字符串，则返回0，第一个字符串小于第二个字符串，则返回小于0的数字3、长度受限制的字符串函数介绍strncpy->拷贝num个字符从源字符串到目标空间。
一网打尽：C语言库函数＜string.h＞
m0_74545731的博客
01-05 396
字符串函数，,,strlen,strcpy,strncpy,strcmp,strncmp,memcpy,memset,strcat,strncat,memmove,strstr,strtok,strerrormemcpy,memchr,strchr
C语言基础（string标准库函数及其实现）
Frank_sample的专栏
03-07 1878
1，memchr --&gt;C 库函数 void *memchr(const void *str, int c, size_t n) 在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。 void *memchr(const char *str,int c,size_t n){ const unsi...
c语言中string函数库,C语言 string.h 中函数的实现
weixin_42298093的博客
05-19 166
最近是校招很热的季节，实验室里讨论最多的也就是算法，面试和笔试的必备知识储备。昨天想起 C 语言中 string.h 中的函数在操作字符串时很方便，所以，就想起写写那些函数。当然，这些函数实现的只是简单的功能，并没有加入太多的排错功能，欢迎大家及时指正代码中出现的问题，谢谢！my_string.h#include #include int my_strcmp(char *string1, char...
C语言的string.h库笔记
陈俞飞的专栏
01-06 2797
最近在研究C语言，C语言本身的语法规则，加上它的C89，C99等标准，还是挺复杂的。除了C语言本身外，它的库函数也是必要的组成部分，本文先简单的分析一下string.h中的函数，参考了C99标准。有些函数（比如strtok）我很少用到，后面用到了再填充吧。 1. memcpy：将源buffer内容的开始n个字节复制到目标buffer中，不检查buffer重叠。 2. memmove：和mem
C语言中string函数库中的一些函数的用法
weixin_53147505的博客
06-16 4851
1、memcpy函数 4、memset函数7、strncat函数10、strdup函数13、strstr函数 2、memmoer函数5、strncpy函数8、strcmp函数11、strndup函数 3、strcpy函数6、strcat函数9、strncmp函数12、strchr函数
<float.h>库函数C语言代码应用
04-22
关于您的问题，<float.h>是C语言标准库中的一个头文件，其中包含了一些宏定义和函数原型，用于处理浮点数相关的操作。您可以使用其中的函数来获取浮点数的各种属性，如最大值、最小值、精度等等。 下面是一个简单的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值