字符以及字符串函数

news2024/12/29 9:12:40

字符以及字符串函数

  • 求字符串长度
    • strlen
  • 长度不受限制的字符串函数
    • strcpy
    • strcat
    • strcmp
  • 长度受限制的字符串函数
    • strncpy
    • strncat
    • strncmp
  • 字符串查找
    • strstr
    • strtok
  • 错误信息报告
    • strerror
  • 字符分类函数
  • 字符转换函数
    • tolower
    • toupper
  • 内存操作函数
    • memcpy
    • memmove
    • memcmp
    • memset

这篇文章注意讲述了库函数中常见字符函数以及字符串函数的使用，以及注意事项，同时模拟实现部分函数.本文主要使用网站链接: cplusplus

求字符串长度

strlen

stelen

  • strlen介绍

size_t strlen(const char* str);

获取字符串长度：C 字符串的长度由终止 null 字符决定：C 字符串的长度与字符串开头和终止 null 字符之间的字符数（不包括终止 null 字符本身）一样长。

  • 头文件：#include<string.h>
  • 参数：字符串
  • 返回值：字符串的长度

注意事项：
1.strlen 是求字符串长度的，求出的长度不可以为负，所以返回类型为size_t，是无符号的（size_t可以看作是umsigned int 类型，但俩者不同之处在于俩个size_t的返回值相减得到的值任然是size_t）
2.字符串已经将’\0’作为结束标志，strlen函数返回的是在字符串中’\0’前面出现的字符个数（不包含’\0’）
3.参数指向的字符串必须要以’\0’为结束标准

  • 实际使用：
//strlen的实际使用
#include<stdio.h>
#include<string.h>
int main(void)
{
	
	char arr[] = "hello!";
	int ret1 = (int)strlen(arr);
	printf("%d\n", ret1);
		
	printf("%d\n", (int)strlen("future"));

	return 0;
}
  • 运行截图：
    stlen
  • 模拟实现：
    方法1：使用计数器模拟实现strlen
#include<stdio.h>
#include<assert.h>
//使用计数器模拟实现strlen
size_t my_strlen(const char* str)
{
	//断言：字符串不能为空
	assert(str);
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int main(void)
{
	char arr[] = "Hello China!";
	//接收字符串长度
	int ret = (int)my_strlen(arr);
	//打印
	printf("%d ",ret);

	return 0;
}

方法2：使用递归模拟实现strlen

//使用递归模拟实现strlen
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
	//断言：字符串不能为空
	assert(str);
	if (*str=='\0')
	{
		return 0;
	}
	else
	{
		return 1 + my_strlen(str+1);
	}
}
int main(void)
{
	char arr[] = "Hello beijing!";
	//接收字符串长度
	int ret = (int)my_strlen(arr);
	//打印
	printf("%d", ret);

	return 0;
}

方法3：使用指针与指针之间的运算模拟实现strlen

#define  _CRT_SECURE_NO_WARNINGS 1	
//使用指针与指针之间的运算模拟实现strlen
#include<stdio.h>
size_t my_strlen(const char* str)
{
	char* s = str;
	while (*s !='\0')
	{
		s++;
	}

		return s - str;
}
int main(void)
{
	char arr[] = "Hello shandong！";
	//接收返回值
	int ret = (int)my_strlen(arr);
	//打印
	printf("%d", ret);

	return 0;
}

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

strcpy

strcpy

  • strcpy介绍

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

拷贝字符串：将源指向的 C 字符串复制到目标指向的数组中，包括终止 null 字符（并在该点停止）

  • 头文件：#include<string.h>
  • 参数destination：指向要复制内容的目标数组的指针
  • 参数source：要复制的 C 字符串
  • 返回值：返回目标数组起始的指针

注意事项：
1.源字符串必须以’\0’结束
2.会将源字符串中的’\0’拷贝到目标空间
3.目标空间必须足够大，以确保能存放源字符串
4.目标空间可变

  • 实际使用：
//strcpy的实际使用
#include<stdio.h>
#include<string.h>
int main(void)
{
	char destination[20] = { 0 };
	char source[] = "Hello shanxi!";
	//拷贝字符串
	strcpy(destination,source);
	//打印destination
	printf("%s\n",destination);

	return 0;
}
  • 运行截图：

strcpy

  • 模拟实现
//模拟实现strcpy
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
	//断言
	assert(dest && src);
	//定义一个返回值
	char* ret = dest;
	while (*src != '\0')
	{
		*dest++ = *src++;
	}
	return ret;
}
int main(void)
{
	//destination数组
	char dest[30] = { 0 };
	//source数组
	char src[] = "Hello neimenggu!";
	//模拟实现strcpy
	my_strcpy(dest, src);
	//打印
	printf("%s",dest);

	return 0;
}

strcat

strcat

  • strcat介绍

char* strcat(char* destinaion,char* source)

追加字符串：将源字符串的副本追加到目标字符串。目标中终止的 null 字符被源的第一个字符覆盖，并且在目标中两者串联形成的新字符串的末尾包含一个 null 字符

  • 头文件：#include<stdio.h>
  • 参数desitination：指向目标数组的指针，该数组应包含 C 字符串，并且足够大以包含连接的结果字符串
  • 参数source：要附加的 C 字符串。这不应与目标重叠
  • 返回值：目标数组的地址

注意事项：
1.源字符串必须以’\0’结束
2.目标空间必须足够大，能容纳下源字符串的内容
3.目标空间必须可以被修改
4.源字符串和目标空间相同时，可能会出现问题，不建议使用strcat

  • 实际使用：
//实际使用strcat
#include<stdio.h>
//头文件
#include<string.h>

int main(void)
{
	char dest[20] = "Hello ";
	char src[] = "gansu！";
	//使用strcat
	strcat(dest, src);
	//打印
	printf("%s", dest);

	return 0;
}
  • 运行截图：
    strcat
  • 模拟实现：
//strcat模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	//将dest的起始位置保存
	char ret = dest;
	//将dest循环至\0
	while (*dest != '\0')
	{
		dest++;
	}
	//将src字符串连接在dest后面
	while (*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	return ret;
}

int main(void)
{
	char dest[30] = "Hello ";
	char src[] = "heilongjiang!";
	//模拟实现strcat
	my_strcat(dest, src);
	//打印
	printf("%s", dest);

	return 0;
}

strcmp

strcmp

  • strcmp介绍：

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

比较俩个字符串:此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对，直到字符不同或达到终止 null 字符.此函数执行字符的二进制比较。

  • 头文件:#include<string.h>
  • 参数:被比较的字符串
  • 返回值:返回一个整数值，该值指示字符串之间的关系:
返回值表明
<0第一个字符串小于第二字符串
0第一个字符串等于第二个字符串
>0第一个字符串大于第二个字符串

注意事项:
1.比较俩个字符串时比较俩个字符串对应位置的ASCII码值(将其转换为2进制比较)
2.在vs环境下返回>0,=0,<0的值

  • 实际使用:
//strcmp的实际使用
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
	//俩个不相等的字符串
	char str1[] = "Hello!";
	char str2[] = "hello!";
	//俩个相等的字符串
	char str3[] = "liaoning";
	char str4[] = "liaoning";
	//比较1和2
	int ret1 = strcmp(str1, str2);
	//打印
	printf("%d\n",ret1);
	//比较3和4
	int ret2 = strcmp(str3, str4);
	//打印
	printf("%d\n", ret2);

	return 0;
}

  • 运行结果:
    strcmp

  • 模拟实现:

#define  _CRT_SECURE_NO_WARNINGS 1	
//strcmp的模式实现
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	//断言
	assert(str1 && str2);
	int cmp = 0;
	//循环相同的字符
	while (*str1 ==*str2)
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2--;
	}
	//比较不同的字符
	if (*str1 > *str2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}
int main(void)
{
	char str1[] = "Hello Tianjin！";
	char str2[] = "Hello tianjin！";
	//模拟实现strcmp
	int ret = my_strcmp(str1, str2);
	//打印
	printf("%d", ret);

	return 0;
}

长度受限制的字符串函数

strncpy

strncpy

  • strncpy介绍:

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

从字符串中复制字符:将源的前 num 个字符复制到目标。如果在复制 num 个字符之前找到源 C 字符串的末尾（由 null 字符表示），则 destination 将用零填充，直到将 num 个字符写入该字符串。

  • 头文件:#include<string.h>
  • 参数destination:指向要复制内容的目标数组的指针
  • 参数source:要复制的 C 字符串
  • 参数num:要从源复制的最大字符数(size_t 是无符号整数类型)
  • 返回值:返回目标数组起始的指针

注意事项:
1.如果 source 的长度大于 num，则不会在目标末尾隐式附加 null 字符。因此，在这种情况下，destination 不应被视为以 null 结尾的 C 字符串(这样读取它会溢出)
2.目的地和源不得重叠
3.如果源字符串的长度小于num,则拷贝完字符串之后,在目标的后面追加0,直到num个

  • 实际使用:
#define  _CRT_SECURE_NO_WARNINGS 1	
//实际使用strncpy
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
	char destination[20] = "***************";
	char source[] = "Hello hebei!";
	//从字符串中复制字符
	strncpy(destination, source, 12);
	//打印
	printf("%s", destination);

	return 0;
}

  • 运行结果:
    strcvpy

  • 模拟实现:

//模拟实现strncpy
#include<stdio.h>
#include<assert.h>
char* my_strncpy(char* destination, const char* source, int num)
{
	assert(destination && source);
	char* ret = destination;
	int i = 0;
	while(num--)
	{
		*destination = *source;
		destination++;
		source++;
	}
	return ret;
}
int main(void)
{
	char dest[] = "***************";
	char src[] = "Hello jilin!";
	//模拟实现strncpy
	my_strncpy(dest, src, 12);
	//打印
	printf("%s", dest);

	return 0;
}

strncat

strncat

  • strncat介绍:

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

从字符串中附加字符:将源的前 num 字符追加到 destination 后，加上一个终止的 null 字符。

  • 头文件:#include<string.h>
  • 参数destination:指向目标数组的指针
  • 参数source:要附加的 C 字符串
  • 参数num:要追加的最大字符数(size_t 是无符号整数类型)

注意事项:
1.如果源代码中 C 字符串的长度小于 num，则仅复制终止 null 字符之前的内容
2.目标数组应包含 C 字符串，并且足够大以包含连接的结果字符串，包括其他 null 字符

  • 实际使用:
//实际使用strncat
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
	char dest[30] = "Hello ";
	char src[] = "xinjiang!";
	//使用strncat
	strncat(dest,src,3);
	//打印
	printf("%s",dest);

	return 0;
}
  • 运行截图:

strncat

  • 模拟实现:
//模拟实现strncap
#include<stdio.h>
#include<assert.h>
char* my_strncat(char* dest, const char* src, int num)
{
	assert(dest && src);
	char* ret = dest;
	//循环dest至结束
	while (*dest)
	{
		dest++;
	}
	//连接字符串
	while (num--)
	{
		*dest = *src;
		dest++;
		src++;
	}
	return ret;
}
int main(void)
{
	char dest[30] = "Hello ";
	char src[] = "xizang!";
	//模拟实现strncap
	my_strncat(dest, src, 2);;
	//打印
	printf("%s",dest);

	return 0;
}

strncmp

strncmp

  • 介绍strncmp:

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

比较两个字符串的字符:将 C 字符串 str1 的字符数与 C 字符串 str2 的字符数进行比较。

  • 头文件:#include<string.h>
  • 参数str1:要比较的 C 字符串
  • 参数str2:要比较的 C 字符串
  • 参数num:要从源复制的最大字符数(size_t 是无符号整数类型)
  • 返回值:返回一个整数值，该值指示字符串之间的关系:
返回值表明
<0第一个字符串小于第二字符串
0第一个字符串等于第二个字符串
>0第一个字符串大于第二个字符串

注意事项:
1.此函数开始比较每个字符串的第一个字符。
2.如果它们彼此相等，则继续执行以下对，直到字符不同，直到达到终止的 null 字符，或者直到两个字符串中的 num 个字符匹配，以先发生者为准

  • 实际使用:
//实际使用strncmp
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
	char str1[] = "Hello Qinghai!";
	char str2[] = "Hello qinghai!";
	//比较字符串
	int ret = strncmp(str1,str2,10);
	//打印
	printf("%d",ret);

	return 0;
}
  • 运行结果:

\strcmp

  • 模拟实现:
//模拟实现strncmp
#include<stdio.h>
#include<assert.h>
int my_strncmp(const char* str1, const char* str2, int num)
{
	assert(str1 && str2);
	while (*str1 == *str2 && num)
	{
		if (*str1 == '\0'||num==0)
		{
			return 0;
		}
		str1++;
		str2++;
		num--;
	}
	if (*str1 > *str2)
	{
		return 1;
	}
	else
		return -1;
}
int main(void)
{
	char str1[] = "Hello Sichuan!";
	char str2[] = "Hello sichuan!";
	//模拟实现比较字符串
	int ret = my_strncmp(str1, str2, 10);
	//打印
	printf("%d",ret);

	return 0;
}

字符串查找

strstr

strstr

  • strstr介绍：

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

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

查找子字符串：返回指向 str1 中首次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回空指针

  • 头文件：#include<string.h>
  • 参数str1：要扫描的 C 字符串
  • 参数str2：包含要匹配的字符序列的 C 字符串
  • 返回值：指向 str1 中指定的整个字符序列在 str1 中首次出现的指针，如果序列在 str1 中不存在，则为空指针

注意事项：
1.匹配过程不包括终止 null 字符

  • 实际使用：
//实际使用strstr
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
	char str1[] = "Hello yunnan!";
	char str2[] = "yunnan";
	//查找子字符串
	char* ret = strstr(str1, str2);
	//打印
	printf("%s",ret);

	return 0;
}
  • 运行结果：

strstr

  • 模拟实现：
//strstr模拟实现
#include<stdio.h>
#include<assert.h>
const char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1!='\0')
	{
		//引用俩个指针代替str1,str2
		char* S1 = str1;
		char* S2 = str2;
		//代替指针进入比较循环
			while (*S1 == *S2&&*S1!='\0' && *S2 != '\0')
			{
					S1++;
					S2++;
			}
			if (*S2 == '\0')
			{
				return str1;
			}
			str1++;
	}
	return NULL;
}
int main(void)
{
	char str1[] = "Hello hainan!";
	char str2[] = "hainan";
	//模拟实现strstr
	char* ret = my_strstr(str1, str2);
	//打印
	printf("%s",ret);

	return 0;
}

strtok

strtok

  • 介绍strtok：

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

将字符串拆分：对此函数的一系列调用将 str 拆分为标记，这些标记是由分隔符中的任何字符分隔的连续字符序列。

  • 头文件：#include<stdio,h>
  • 参数str：要截断的 C 字符串
  • 参数delimiters：包含分隔符的 C 字符串
  • 返回值：如果找到分隔符，则指向分隔符开头的指针，否则为空指针

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

  • 实际使用：
//实际使用strtok
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
	const char str1[] = "Hello!China*I love you+lalalala";
	const char del[] = "!*+";
	char* ret = NULL;
	char s[50];
	//拷贝字符串
	strcpy(s, str1);
	//分割打印
	for (ret = strtok(s, del); ret != NULL; ret = strtok(NULL, del))
	{
		printf("%s\n",ret);
	}

	return 0;
}
  • 运行结果：

strtok

错误信息报告

strerror

strerro

  • 介绍strerror：

char* strerror(int errnum)

获得一个指向错误信息的地址：解释 errnum 的值，生成一个字符串，其中包含一条消息，该消息描述错误条件，就像库的函数设置为 errno 一样。返回的指针指向静态分配的字符串，程序不得修改该字符串。对此函数的进一步调用可能会覆盖其内容（不需要特定的库实现来避免数据争用）。strerror 生成的错误字符串可能特定于每个系统和库实现。

  • 头文件：#include<stdio.h>
  • 参数errnum：错误码
  • 返回值：错误信息的地址

注意事项：
1.c语言的库函数在运行的时候，如果发生错误，就会将错误存在一个变量中，这个变量是：errno
2.错误码是一些数字：1，2，3，4，5
3.我们需要将错误码翻译成错误信息

  • 实际使用：
//实际使用strerror
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main(void)
{
	//打开文件
	FILE* pf = fopen("my.txt","r");
	if (pf == NULL)
	{
		printf("%s",strerror(errno));
	}

	return 0;
}
  • 运行结果：

strerror

字符分类函数

函数参数符合条件则返回真
iscntrl任何控制字符
isspace空白字符:空格’ ‘,换页’\f’,换行’\n’,回车’\r’,制表符’\t’或者垂直制表符’\v’
isdigit十进制数字0~9
iscdigit十六进制数字,包括十进制数字,小写字母a-f,大写字母A-F
islower小写字母a-f
isupper大写字母A-F
isalpha字母a-z或A-Z
isalnum字母或者数字0-9,a-z,A-Z
ispunct标点符号,任何不属于数字或者字母的图形字符(可打印)
isgraph任何图形字符
isprint任何可打印字符,包括图形字符和空白字符

字符转换函数

tolower

int tolower(int c)

将大写字母转换为小写

toupper

int toupper(int c)

将小写字母转换为大写

内存操作函数

memcpy

memcpy

  • 介绍memcpy

void* memcpy(void* destination,const void* source,size_t um)

复制内存块:将 num 字节的值从源指向的位置直接复制到目标指向的内存块

  • 头文件：#include<string.h>
  • 参数destination：指向要拷贝内容的目标数组的指针，类型转换为 void* 类型的指针
  • 参数source：指向要拷贝的数据源的指针，类型转换为类型为 const void* 的指针。
  • 参数num：要拷贝的字节数（size_t 是无符号整数类型）
  • 返回值：返回destination的指针

注意事项：
1.strcpy只能拷贝字符串，而memcpy可以拷贝内存块
2.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置
3.这个函数在遇到’\0’的时候并不会停下来
4.如果source和的destination有任何的重叠，复制的内容都是未定义的

  • 实际使用：
//实际使用memcpy
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
	int src[] = {1,2,3,4,5};
	int dest[10];
	//使用memcpy
	memcpy(dest,src,sizeof(src));
	//打印
	int i = 0;
	for (i = 0; i < (sizeof(src) / sizeof(src[0])); i++)
	{
		printf("%d ",dest[i]);
	}
	return 0;
}
  • 运行结果：

memcpy

  • 模拟实现：
//模拟实现memcpy
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}

	return ret;
}
int main(void)
{
	int src[] = { 1,2,3,4,5,6,7,8,9 };
	int dest[10] = { 0 };
	//实现memcpy
	my_memcpy(dest, src+3, 17);
	//打印
	int i = 0;
	for (i = 0; i < (17 / sizeof(int)); i++)
	{
		printf("%d ",dest[i]);
	}

	return 0;
}

memmove

memmove

  • 介绍memmove:

void* memcpy(void* destination,const void* source,size_t um)

移动内存块:将 num 字节的值从源指向的位置复制到目标指向的内存块。复制就像使用了中间缓冲区一样进行，允许目标和源重叠

  • 头文件：#include<string.h>
  • 参数destination：指向要复制内容的目标数组的指针，类型转换为 void* 类型的指针
  • 参数source：指向要复制的数据源的指针，类型转换为类型为 const void* 的指针。
  • 参数num：要复制的字节数（size_t 是无符号整数类型）
  • 返回值：返回destination的指针

注意事项：
1.与memcpy的差别就是memmove函数处理的源内存和目标内存块是可以重叠的
2.如果源空间和目标空间出现重叠，就可以使用memmove

  • 实际使用：
//实际使用memmove
#include<stdio.h>
#include<string.h>
int main(void)
{
	int str[] = { 1,2,3,4,5,6,7,8 };
	//使用memmove
		//模拟实现memmove
	memmove(str + 2, str, 20);
	//打印
	int i = 0;
	for (i = 0; i < (sizeof(str) / sizeof(str[0])); i++)
	{
		printf("%d ", str[i]);
	}

	return 0;
}
  • 运行结果：

memmove

  • 模拟实现：
//模拟实现memmove
#include<stdio.h>
#include<assert.h>
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(void)
{
	int str[] = { 1,2,3,4,5,6,7,8,9,10 };
	//模拟实现memmove
	my_memmove(str + 2, str, 20);
	//打印
	int i = 0;
	for (i = 0; i < (sizeof(str) / sizeof(str[0])); i++)
	{
		printf("%d ",str[i]);
	}

	return 0;
}

memcmp

memcmp
比较俩个内存块：将 ptr1 指向的内存块的第一个 num 字节与 ptr2 指向的第一个 num 字节进行比较，如果它们都匹配，则返回零，或者如果它们不匹配，则返回与零不同的值，表示哪个值更大

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

  • 头文件：#include<string.h>
  • 参数ptr1：指向内存块的指针
  • 参数ptr2：指向内存块的指针
  • 参数num：要比较的字节数
  • 返回值：返回一个整数值，该值指示字符串之间的关系
返回值表明
<0在两个内存块中不匹配的第一个字节在 PTR1 中的值低于 PTR2 中的值（如果计算为无符号字符值）
0两个内存块的内容相等
>0在两个内存块中不匹配的第一个字节在 PTR1 中的值高于 PTR2 中的值（如果计算为无符号字符值）
  • 实际使用：
//实际使用memcmp
#include<stdio.h>
#include<string.h>
int main(void)
{
	int str1[] = { 1,2,3,4,5 };
	int str2[] = { 1,2,5,4,5 };
	//实际使用memcmp
	int ret = memcmp(str1, str2,4);
	//打印
	printf("%d\n",ret);

	ret = memcmp(str1, str2, 12);
	//打印
	printf("%d\n", ret);

	return 0;
}
  • 运行结果：

memcmp

memset

memset

  • 介绍memset:

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

填充内存块:将 ptr 指向的内存块的第一个 num 字节设置为指定值（解释为无符号字符）

  • 头文件：#include<stdio.h>

  • 参数ptr：指向要填充的内存块的指针

  • 参数value:要设置的值，该值作为 int 传递，但该函数使用此值的无符号字符转换填充内存块

  • 参数num:要填充的字节数（size_t 是无符号整数类型）

  • 返回值：返回 ptr的指针

  • 实际使用：

//实际使用memset
#include<stdio.h>
#include<string.h>
int main(void)
{
	char str[] = "************";
	//实际使用memset
	memset(str, 'a', 5);
	//打印
	printf("%s",str);

	return 0;
}
  • 运行结果：

memset

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1661990.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【算法】Dijkstra求最短路算法

【算法】Dijkstra求最短路算法

TOP提示&#xff1a;Dijkstra算法只适用于不含负权边的情况 Dijkstra算法是一个基于贪心&#xff0c;广搜和动态规划 求图中某点到其他所有点的最短路径的算法 一、步骤 首先我们先总结Dijkstra算法的完整步骤 我们需要一个dis数组存储从起点到达其他节点的最短距离&…
阅读更多...
【小迪安全2023】第62天:服务攻防-框架安全CVE复现SpringStrutsLaravelThinkPHP

【小迪安全2023】第62天:服务攻防-框架安全CVE复现SpringStrutsLaravelThinkPHP

&#x1f36c; 博主介绍&#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;我是 hacker-routing &#xff0c;很高兴认识大家~ ✨主攻领域&#xff1a;【渗透领域】【应急响应】 【Java、PHP】 【VulnHub靶场复现】【面试分析】 &#x1f389;点赞➕评论➕收…
阅读更多...
【影片欣赏】【指环王】【魔戒：国王归来 The Lord of the Rings: The Return of the King】

【影片欣赏】【指环王】【魔戒：国王归来 The Lord of the Rings: The Return of the King】

往期魔戒博客见&#xff1a; 【影片欣赏】【指环王】【魔戒&#xff1a;护戒使者 The Lord of the Rings: The Fellowship of the Ring】 【影片欣赏】【指环王】【魔戒&#xff1a;双塔奇谋 The Lord of the Rings: The Two Towers】 2004年发行&#xff0c;Special Extend…
阅读更多...
控制情绪是交易成功的根本？大错特错

控制情绪是交易成功的根本？大错特错

布雷特斯坦伯格&#xff08;Brett Steenbarger&#xff09;是一位在美国享有盛誉的交易心理学专家&#xff0c;他曾在华尔街的多个顶尖培训中心担任交易员的心理指导。身为心理学教授兼高级交易员的布雷特在交易心理方面要比别人了解得多。而且小编觉得做一个成功的交易员只靠交…
阅读更多...
[c++]多态的分析

[c++]多态的分析

多态详细解读 多态的概念多态的构成条件 接口继承和实现继承: 多态的原理:动态绑定和静态绑定 多继承中的虚函数表 多态的概念 -通俗的来说&#xff1a;当不同的对象去完成某同一行为时&#xff0c;会产生不同的状态。 多态的构成条件 必须通过基类的指针或者引用调用虚函数1虚…
阅读更多...
KMeans，KNN，Mean-shift算法的学习

KMeans，KNN，Mean-shift算法的学习

1.KMeans算法是什么&#xff1f; 在没有标准标签的情况下&#xff0c;以空间的k个节点为中心进行聚类&#xff0c;对最靠近他们的对象进行归类。 2.KMeans公式&#xff1a; 2. 1.关键分为三个部分&#xff1a; 1.一开始会定义n个中心点&#xff0c;然后计算各数据点与中心点…
阅读更多...
重装前端整体流程

重装前端整体流程

用户管理 --汇总 -- 明细-CSDN博客 一、node 这个看环境变量 2023最新版Node.js下载安装及环境配置教程&#xff08;非常详细&#xff09;从零基础入门到精通&#xff0c;看完这一篇就够了_nodejs安装及环境配置-CSDN博客 配置到国内镜像的时候&#xff0c;去看&#xff0c;淘…
阅读更多...
05.线程

05.线程

进程有哪些缺陷&#xff1f; 1.创建的代价较高 进程是OS进行资源分配的基本单位&#xff0c;也就是说创建进程是需要分配资源的&#xff0c;所以创建代价很高 2.通信不方便 进程之间要想进行通信必须借助第三方资源&#xff08;管道、内存映射、消息队列&#xff09; 线程的优…
阅读更多...
在线教程|二次元的福音！一键部署APISR，动漫画质飞跃升级

在线教程|二次元的福音！一键部署APISR，动漫画质飞跃升级

从守护城市安全的「火眼金睛」&#xff0c;到探索人体奥秘的医学之窗&#xff0c;再到娱乐产业的视觉盛宴&#xff0c;乃至遥望宇宙的卫星视角&#xff0c;超分辨率技术重塑着我们观察世界的新维度&#xff0c;让每一寸画面绽放前所未有的清晰与真实。 近年来&#xff0c;越来…
阅读更多...
【C++】C++中的template模板

【C++】C++中的template模板

一、泛型编程 关于模板的出现其实是在广大程序员编程中偷懒省下来的。我举个例子你们就知道了。 下述例子是用来实现swap函数的&#xff0c;利用的方式是最基础的重载。 void Swap(int& left, int& right) {int temp left;left right;right temp; } void Swap(d…
阅读更多...
【Linux操作系统】:文件操作

【Linux操作系统】:文件操作

目录 前言 一、C语言中文件IO操作 1.文件的打开方式 2.fopen&#xff1a;打开文件 3.fread&#xff1a;读文件 4.fwrite:写文件 二、系统文件I/O 1.系统调用open、read、write 2.文件描述符fd 3.文件描述符的分配规则 4.重定向 5.缓冲区 6.理解文件系统 磁盘 磁盘…
阅读更多...
掌握这几点，稳稳拿下中质协六西格玛考试！

掌握这几点，稳稳拿下中质协六西格玛考试！

在当今竞争激烈的市场环境中&#xff0c;拥有六西格玛证书无疑是提升自身职业竞争力的一大利器。中质协作为权威机构&#xff0c;其六西格玛考试更是备受关注。那么&#xff0c;如何才能稳稳拿下这场考试呢&#xff1f;深圳天行健六西格玛管理培训公司有建议如下&#xff1a; 一…
阅读更多...
【计算机毕业设计】springboot国风彩妆网站

【计算机毕业设计】springboot国风彩妆网站

二十一世纪我们的社会进入了信息时代&#xff0c; 信息管理系统的建立&#xff0c;大大提高了人们信息化水平。传统的管理方式对时间、地点的限制太多&#xff0c;而在线管理系统刚好能满足这些需求&#xff0c;在线管理系统突破了传统管理方式的局限性。于是本文针对这一需求设…
阅读更多...
影刀进行shopee商品排名零代码爬取

影刀进行shopee商品排名零代码爬取

需要研究shopee平台的排名更新时间段和周期&#xff0c;几分钟用影刀写了一个爬取应用&#xff0c;每10分钟进行一次排名爬取&#xff08;以fan‘风扇’为例&#xff09;&#xff0c;0代码爬取。 打开’fan’关键词搜索网页&#xff1b;等待网页加载&#xff1b;滚动进一步加载…
阅读更多...
计算机服务器中了devicdata勒索病毒如何解密，devicdata勒索病毒解密恢复工具

计算机服务器中了devicdata勒索病毒如何解密，devicdata勒索病毒解密恢复工具

在网络技术飞速发展的时代&#xff0c;有效地利用网络开展各项工作业务&#xff0c;能够大大提升企业的生产运行效率&#xff0c;改善企业的发展运营模式&#xff0c;但如果网络利用不好就会给企业的数据安全带来严重威胁。近日&#xff0c;云天数据恢复中心接到很多企业的求助…
阅读更多...
复制粘贴插件——clipboard.js的使用

复制粘贴插件——clipboard.js的使用

clipboard.js是一款使用简单的粘贴复制插件,它不依赖于Flash或其他框架&#xff0c;在github拥有3万多颗星可见其优秀程度&#xff0c;介绍如何使用它&#xff0c;以备存。 中文文档&#xff1a; clipboard.js 中文文档 - itxst.com 官网网站&#xff1a;https://github.com/…
阅读更多...
【C++】 类的6个默认成员函数

【C++】 类的6个默认成员函数

目录 1. 类的6个默认成员函数 一.构造函数 1.基本概念 2 特性 注意&#xff1a;C11 中针对内置类型成员不初始化的缺陷&#xff0c;又打了补丁&#xff0c; 3.构造函数详解 3.1构造函数体赋值 3.2 初始化列表 3.3 explicit关键字 二.析构函数 1 概念 2 特性 两个栈实…
阅读更多...
安装vmware station记录

安装vmware station记录

想学一下linux,花了3个多小时&#xff0c;才配置好了&#xff0c;记录一下 安装vm12,已配置linux系统 报错&#xff0c;VMware Workstation 与 Device/Credential Guard 不兼容解决方案&#xff0c;网上说有不成功的&#xff0c;电脑蓝屏&#xff0c;选择装vm16试试 vm16 在…
阅读更多...
多个.C文件被编译为一个可执行文件的详细过程

多个.C文件被编译为一个可执行文件的详细过程

多个.C文件被编译为一个可执行文件的详细过程 文章目录 多个.C文件被编译为一个可执行文件的详细过程前言一、一个.C文件的编译过程二、多个.C文件的链接过程1.文件信息2.链接过程3.makefile 总结 前言 C语言经典的 “hello world ” 程序从编写、编译到运行&#xff0c;看到屏…
阅读更多...
electron-vite工具打包后通过内置配置文件动态修改接口地址实现方法

electron-vite工具打包后通过内置配置文件动态修改接口地址实现方法

系列文章目录 electronvitevue3 快速入门教程 文章目录 系列文章目录前言一、实现过程二、代码演示1.resources/env.json2.App.vue3.main/index.js4.request.js5.安装后修改 前言 使用electron-vite 工具开发项目打包完后每次要改接口地址都要重新打包&#xff0c;对于多环境…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023