字符串函数(strlen,strcpy,strcat,strcmp,strncpy,strncat,strncmp,strstr,strtok）-函数的使用和模拟

最新推荐文章于 2023-04-26 21:28:01 发布
最新推荐文章于 2023-04-26 21:28:01 发布
阅读量1k 收藏 4
点赞数
分类专栏： C语言 文章标签： c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60658529/article/details/123750508
版权

目录

  • 求字符串长度
    strlen
  • 长度不受限制的字符串长度
    strcpy
    strcat
    strcmp
  • 长度受限制的字符串长度
    strncpy
    strncat
    strncmp
  • 字符串查找
    strstr
    strtok
    ------------------------------------------分割线----------------------------------------------

0.前言

在C语言中，字符和字符串使用和处理十分的频繁，但是C语言本身是没有字符串类型的，字符串常常放在常量字符串或者字符数组中。

字符串常量适用于那些对它不做修改的字符串常量。

1.函数介绍

1.1 strlen

size_t strlen(const char*string);   //strlen函数的一般形式
  • 在C语言中，字符串是以’\0’作为标志，strlen函数返回的是在字符串中’\0’前面的字符的个数。
  • strlen使用的条件是其所指向的字符串必须以’\0’结束。
  • 注意strlen函数的返回值size_t是无符号的（易错点）
  • 使用strlen函数，需要引用头文件#include<string.h>。

strlen函数的使用：

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

int main()
{
	//字符数组的初始化
	char str1[] = "abcdefg";
	char str2[] = "acfsd";

	if(strlen(str1)>strlen(str2))
	{
		printf(">");
	}
	else
	{
		printf("<");
	}
	return 0;
}

运行结果：
在这里插入图片描述

strlen函数的模拟实现：

//strle函数的模拟实现

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

int my_strlen(char* str)   //返回类型为int,形参用指针的形式接收实参
{
	int count = 0;				//定义'\0'之前字符的个数
	while(*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	//字符数组的初始化
	char str1[] = "abcdefg";
	char str2[] = "acfsd";
	if (my_strlen(str1) > my_strlen(str2))
	{
		printf(">");
	}
	else
	{
		printf("<");
	}
	return 0;
}

运行结果：
在这里插入图片描述

1.2 strcpy函数

char* strcpy(char* dest, const char* src);  //strcpy函数的一般形式
  • 将源指向的C字符串复制到目标指向的数组中，包括终止的空字符(并在该点停止)。
  • 源字符串必须以’\0’结束。
  • 会将源字符串中的’\0’拷贝到目标空间。(详解见下文代码)
  • 目标空间必须足够大，以确保能存放源字符串。
  • 目标空间必须可变。
  • 使用strlen函数，需要引用头文件#include<string.h>。

strcpy函数的使用：

//strcpy函数的使用

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

int main()
{
	const char* str1 = "abcdefgh"; //str1指向的是常量字符串，常量是不可修改的
	char str2[20] ="poiuyt";	   //目标空间是可变的，并且足够大
	int sz = sizeof(str2) / sizeof(str2[0]);
	strcpy(str2, str1);			   //这里注意源字符串和目标字符串在函数中的前后位置
	printf("%s\n", str2);	       
	
	return 0;
}

运行结果：
在这里插入图片描述

验证源字符串中的’\0’拷贝到目标空间：
在这里插入图片描述strcpy函数的模拟实现（初阶版）：

//strcpy函数的使用

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

char* my_strcpy(char* dest, char* src)  
{
	char* ret = dest;					//strcpy函数返回的是目标函数的起始地址
	while (*src != '\0')
	{
		*(dest) = *(src);
		dest++;
		src++;
	}
	return ret;
}

int main()
{
	const char* str1 = "abcdefgh"; //str1指向的是常量字符串，常量是不可修改的
	char str2[50] ="poiuytxxxxxxxxxxxxx";	   //目标空间是可变的，并且足够大
	int sz = sizeof(str2) / sizeof(str2[0]);
	my_strcpy(str2, str1);			   //这里注意源字符串和目标字符串在函数中的前后位置
	printf("%s\n", str2);	       
	
	return 0;
}

运行结果：
在这里插入图片描述
strcpy函数的模拟实现（进阶版）：

//strcpy函数的使用（进阶版）

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

char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);        //对dest和src进行断言，确保其是有效指针
	char* ret = dest;			//strcpy函数返回的是目标函数的起始地址
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	const char* str1 = "abcdefgh"; //str1指向的是常量字符串，常量是不可修改的
	char str2[50] = "poiuytxxxxxxxxxxxxx";	   //目标空间是可变的，并且足够大
	int sz = sizeof(str2) / sizeof(str2[0]);
	printf("%s\n", my_strcpy(str2, str1)); //链式访问

	return 0;
}

运行结果：
在这里插入图片描述

**这里初阶版和进阶版的运行结果并不相同，大家可以思考一下为什么。。

1.3 strcat函数

char* strcat(char* dest, const char* src);  //strcat函数的一般形式
  • 源字符串必须以’\0’结束。
  • 目标空间必须足够大，能够容纳源字符穿串的内容。
  • 目标必须可以可以修改。
  • 需要引用头文件#include<string.h>。

strcat函数的使用：

//strcat函数

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

int main()
{
	char* str1 = "abcdefgh";
	char str2[30] = "abcd";
	strcat(str2, str1);
	printf("%s\n", str2);
	return 0;
}

运行结果：
在这里插入图片描述strcat函数的模拟实现（初阶版）：

//strcat函数的模拟实现

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

char* my_strcat(char* dest,const char* src)
{
	char* ret = dest;                 
	while (*(src) != '\0')
	{
		dest++;				
		if (*dest == '\0')   //dest为字符串str2的首字符地址，对其自增，找到其末尾的地址
		{
			*dest = *src;	//将str1的第一个字符赋值给str2的最后一个字符
			src++;          //src自增，指向str1的下一个字符
		}
	}
	return ret;
}
int main()
{
	char* str1 = "world";
	char str2[30] = "hello";
	my_strcat(str2, str1);
	printf("%s\n", str2);

	return 0;
}

strcat函数的模拟实现（进阶版）：

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest&&src);   //对dest和src进行断言，确保其是有效指针
	char* ret = dest;
	while (*dest)     //找到字符串str2的'\0'处的地址
	{
		dest++;
	}
	while (*dest++ = *src++)  //将字符串str1的内容拷贝到str2的'\0'往后，覆盖'\0'
	{
		;
	}
	return ret;
}
int main()
{
	char* str1 = "world";
	char str2[30] = "hello";
	printf("%s\n", my_strcat(str2, str1));
	return 0;
}

运行结果：
在这里插入图片描述

如何让字符串对自己进行追加，结果会怎么样呢？大家可以思考一下。。

1.4 strcmp函数

int strcmp(const char* str1, const char* str2);  //strcmp函数的一般形式
  • 这个函数开始比较每个字符串的第一个字符。如果它们相等，则继续执行下面的对，直到字符不同或到达一个结束的空字符为止。
  • 标准规定：
  • 第一个字符串大于第二个字符串，则返回大于0的数字。
  • 第一个字符串等于第二个字符串，则返回0。
  • 第一个字符串小于第二个字符串，则返回小于0的数字。
  • 需要引用头文件#include<string.h>。

strcmp函数的使用:

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

int main()
{
	char*str1 = "halloe";
	char*str2= "hello";
	int ret=strcmp(str1, str2);  //将函数返回值设为ret

	//对ret进行判断
	if (ret>0)
	{
		printf("str1>str2\n");
	}
	else if (ret == 0)
	{
		printf("str1 =str2\n");
	}
	else
	{
		printf("str1<str2\n");
	}
	return 0;
}

strcmp函模拟实现:

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

int my_strcmp(char* str1, char* str2)
{
	assert(str1,str2);

	while(*str1==*str2)
	{
		//相等
		if (str1 =='\0')		
		{
			return 0;
		}
		str1++;
		str2++;
	}

		//不相等
	if (*str1 > *str2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}
int main()
{
	char* str1 = "hello";
	char* str2 = "helloaa";
	int ret = my_strcmp(str1, str2);  //将函数返回值设为ret
	//对ret进行判断
	if (ret > 0)
	{
		printf("str1>str2\n");
	}
	else if (ret == 0)
	{
		printf("str1 =str2\n");
	}
	else
	{
		printf("str1<str2\n");
	}
	return 0;
}

> strcmp函数比较的不是两个字符串的大小，而是比较两个字符串对应位置上字符的大小，如果相等就跳过比较下一对字符，直至遇到不同的字符或者’\0’

1.5 strncpy函数

char* strncpy(char* dest, const char* src, size_t num);   //strncpy函数的一般形式
  • 将源的第一个num字符复制到目标。 如果源C字符串结束 (以空字符为标志)在复制num字符之前找到， 目的地用零填充，直到向其写入总数为num的字符。
  • 拷贝num个字符到目标空间。
  • 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标后面追加0，直到num个(见下文详解1)。
  • 需要引用头文件#include<string.h>。

strncpy函数的使用：

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

int main()
{
	char str1[]= "qwe";
	char str2[30]= "abcdef";
	strncpy(str2, str1, 5);
	printf("%s\n", str2);
	return 0;
}

运行结果：
在这里插入图片描述
详解1：
在这里插入图片描述

1.6 strncat函数

char* strncat(char* dest, const char* src, size_t num);   //strncat函数的一般形式
  • 将源的第一个num字符添加到目标，并加上一个结束的空字符（这里我们可以验证一下这个空字符是加上的还是目标字符本身自带的，见详解2）。
  • 如果源代码中C字符串的长度小于num，则只包含结束之前的内容null字符复制。
  • 需要引用头文件#include<string.h>。

strncat函数的使用：

#include<stdio.h>
#include<string.h>
int main()
{
	char str1[]= "qwe";
	char str2[30]= "abcdef";
	strncat(str2, str1, 5);
	printf("%s\n", str2);
	return 0;
}

运行结果：
在这里插入图片描述详解2：
在这里插入图片描述

1.7 strncmp函数

int strncmp(const char* str1, const char* str2, size_t num);  //strncmp函数的一般形式

-str1和str2的比较范围为num个字符，即只逐一比较num个字符之前的对应每个字符的大小。

  • 标准规定：
  • 第一个字符串大于第二个字符串，则返回大于0的数字。
  • 第一个字符串等于第二个字符串，则返回0。
  • 第一个字符串小于第二个字符串，则返回小于0的数字。
  • 需要引用头文件#include<string.h>。

strncmp函数的使用：

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

int main()
{
	char str1[] = "abcdefgh";
	char str2[] = "abcdeggh";
	int ret =strncmp(str1, str2, 2);
	if (ret > 0)
	{
		printf("str1>str2");
	}
	else if (ret == 0)
	{
		printf("str1=str2");
	}
	else
	{
		printf("str1>str2");
	}
	return 0;
}

运行结果：
在这里插入图片描述

strcmp函数和strncmp函数的相同点和不同点是什么呢？大家可以思考一下。。。

1.8 strstr函数

int strstr(const char* str1, const char* str2);   //strstr函数的一般形式
  • 返回一个指向str1中第一次出现str2的指针，如果str2不是其中的一部分，则返回一个空指针
    str1(即判断str2是否是str1的子串)。
  • 如果是，就返回str2首次出现在str1中的地址；如果不是，就返回空指针。
  • 需要引用头文件#include<string.h>。

strstr函数的使用

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

int main()
{
	char str1[]= "abcdefgh";
	char str2[]= "cd";
	char* ret=strstr(str1, str2);
	if (NULL == ret)
	{
		printf("找不到子串！\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

运行结果：
在这里插入图片描述
strstr函数的模拟（初阶版）：

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

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);   //对str1和str2断言

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

	if (*str2 == *str1)    //第一个字符相等
	{
		while (*str2)
		{
			if (*str2!= *str1)   //从第一个字符开始，同步遍历str1，str2，若出现不同的字符，则返回NULL
				return NULL;
			str1++;
			str2++;
		}
		return s1;				//遍历完成，没有出现不同的字符，说明str2是str1的子串，返回str1的首字符地址
	}
	else                        //第一个字符不相等 
	{
		while (*str1 != 0)   
		{
			str1++;
			if (*str2 == *str1)		//往后遍历，找与str2首字符相同的字符
			{
				char*cur = str1;   //记录此时str1的地址
				while (*str2)    
				{
					if (*str2 != *str1)
						return NULL;
					str2++; 
					str1++;
				}
				return cur;
			}
		}           
	}
}
int main()
{
	char str1[]= "abcdefgh";
	char str2[]= "ef";
	char* ret=my_strstr(str1, str2);
	if (NULL == ret)
	{
		printf("找不到子串！\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

运行结果：
在这里插入图片描述
strstr函数的模拟（进阶版）：

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

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

	const char* cur = str1;        //定义一个cur指针指向str1

	while (*cur)
	{
		s1 = cur;					
		s2 = str2;					//初始化s2的位置
		while (*s1 && *s2 && (*s1 == *s2))   //通过移动cur的位置，找到s1和s2相同的字符，随后s1和s2同步往后遍历
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')					//s1和s2的遍历的每一个字符都相同
		{
			return cur;
		}
		cur++;						//遍历str1的
	}
	return NULL;
}

int main()
{
	char str1[] = "abcdefgh";
	char str2[] = "bcd";
	char* ret = my_strstr(str1, str2);
	if (NULL == ret)
	{
		printf("找不到子串！\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

运行结果：
在这里插入图片描述

1.9 strtok函数

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

strtok函数的使用（初阶版）：

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

int main()
{
	char str1[]= "abndfg@fdff.dsfsf ";
	char str2[30] = { 0 };  

	strcpy(str2,str1);					//将str1拷贝到str2中
	const char*sep = "@.";

	printf("%s\n", strtok(str2,sep)); //只找第一个标记
	printf("%s\n", strtok(NULL,sep)); //从保存的位置继续往后找
	printf("%s\n", strtok(NULL,sep)); //从保存的位置继续往后找

	return 0;
}

运行结果：
在这里插入图片描述

strtok函数的使用（进阶版）：

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

int main()
{
	char str1[] = "abndfg@fdff.dsfsf ";
	char str2[30] = { 0 };

	strcpy(str2, str1);					//将str1拷贝给str2;

	const char* sep = "@.";

	char* str = NULL;                   //定义一个空指针

	for (str = strtok(str2, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}
	return 0;
}

运行结果（进阶版）：

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

int main()
{
	char str1[] = "abndfg@fdff.dsfsf ";
	char str2[30] = { 0 };

	strcpy(str2, str1);					//将str1拷贝给str2;

	const char* sep = "@.";

	char* str = NULL;                   //定义一个空指针

	for (str = strtok(str2, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}
	return 0;
}

运行结果：
在这里插入图片描述

再见青山
关注
专栏目录
C语言之字符串探究(五)：N系列字符串函数——strncpy、strncat、strncmp
小勇博客
01-09 389
  N系列函数存在的意义，就是在避免写越界。   一.strncpy   strcpy( )不能检查目标空间是否能容纳源字符串的副本。拷贝字符串用strncpy( )更安全，该函数的第3个参数指明可拷贝的最大字符数。 例1： 运行结果： 附例1代码： //小问学编程 #include<stdio.h> int main(void) { char* p = "123456"; char str[10]; strncpy(str,p,10); //将读到的'\0',写入str
C语言之字符串探究(三)：字符串库函数操作——strlen、strcat、strcpy、strcmp
小勇博客
01-06 340
待更新
【C进阶】字符串函数（strlen、strcpy、strcat、strcmp、strncpy、strncat、strncmp、strstr、strtok、strerror）
qq_53180719的博客
11-01 526
1.字符串函数 2. 内存函数
常考字符串函数，内存函数总结大全
DR5200的博客
02-07 1707
文章目录求字符串长度strlen长度不受限制的字符串函数1.strcpy2.strcat3.strcmp长度受限制的字符串函数介绍1.strncpy2.strncat3.strncmp字符串查找1.strstr2.strtok错误信息报告strerror字符分类函数内存操作函数1.memcpy2.memmove3.memcmp 求字符串长度 strlen size_t strlen ( const char * str ); 1.字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\
strncpy strcpy memcpy strnprintf strlen等字符串函数的用法和区别
移步换景的博客
09-27 458
C 标准库 - <string.h> char *strcpy(char *dest, const char *src) 把 src 所指向的字符串复制到 dest。如果目标数组 dest 不够大，而源字符串的长度又太长，可能会造成缓冲溢出的情况。该函数返回一个指向最终的目标字符串 dest 的指针. char *strncpy(char *dest, const char *src, size_t n) 把 src 所指向的字符串复制到 dest，最多复制 n 个字符。当 src 的长度小于
sizeof strlen strncpy用法总结 结构体实际所占内存大小 以及memset用法
12-19 248
sizeof测类型（数组名除外） strlen测实际长度 strncpy返回指针类型 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 int main() 5 { 6 char *p="wangddd"; 7 print...
strlen,strcpy,strncpy,strcmp,strcat,strstr的用法，函数原型及函数的实现
wMaiYniJ的博客
06-16 516
strlen,strcpy,strncpy,strcmp,strcat,strstr的用法，函数原型及函数的实现
C语言模拟实现库函数strlen、strcpy、strcat、strcmp、strncpy、strncat、strncmp、strstr、strtok、memcpy、memmove、memcmp
m0_71568805的博客
03-10 458
注意：所有库函数头文件都是C 库函数 size_t strlen(const char *str) 计算字符串 str 的长度，直到空结束字符，但不包括空结束字符,这里注意一点,再用sizeof求内存大小时会计算到'\0'下面是 strlen() 函数的声明。该函数返回字符串的长度。#include #include int is_prime_values_my_strlen(char* str) { //断言 assert(s
《模拟实现字符串函数》（包括strlen,strcpy,strcat,strcmp,strncpy,strncat,strncmp,strstr）
mzqyyds的博客
05-17 381
模拟实现字符串函，包括strlen,strcpy,strcat,strcmp,strncpy,strncat,strncmp,strstr
字符串函数和字符函数详解——strlen,strcpy,strcat,strcmp......
qq_51419689的博客
03-08 394
strlen size_t strlen( const char *string ); 1 字符串以 \0 作为结束标志,strlen函数返回的是 \0之前出现的字符个数 2 字符串必须以 \0 结束 3 返回值为 size_t ，是无符号类型 strcpy char *strcpy( char *strDestination, const char *strSource ); 1 源字符串必须以 \0结束 2 会将源字符串的 \0拷贝到源字符串 3 目标空间必须足够大且是可变的 书写函数模拟实现 #
字符串函数讲解1(strlen、strcpy和strncpy）
weixin_52671375的博客
03-14 788
1.strlen 2.strcpy、strncpy 1.strlen 功能：求字符串长度-------> size_t strlen(const char* str) 注：函数的返回值是size_t是无符号类型(unsigned int)；strlen找到'\0'就会停下来(不包括含'\0')。 strlen的模拟实现 //模拟实现strlen //1.计数器的方式 //2.不能创建临时变量计数器 (递归) //3.指针-指针方式 int my_strlen(const cha..
C语言第27天，字符串函数使用与剖析（一），strlen，strcpy，strcat，strcmp，strncpy，strncat，strcmp
wdnmd____c的博客
07-29 88
strlen - 求字符串长度 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <string.h> //strlen - 求字符串长度 //字符串以'\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数(不包含'\0') //参数指向的字符串必须要以'\0'结束 //注意函数的返回值为size_t，是无符号的 int my_strlen(char* str) { int co
C语言 字符串 内存函数介绍 模拟实现strcpy strcmp strlen strcat strncpy strncmp strncat strstr strtok memcpy memmove
凡事都是靠练习
01-23 912
C语言 字符串 内存函数介绍 模拟实现strcpy strcmp strlen strcat strncpy strncmp strncat strstr strtok memcpy memmove
C语言-str家族之strlen,strcpy,strncpy
qq_58601798的博客
07-06 468
C语言-str家族之strlen,strcpy,strncpy代码原理及使用
strlen,strcpy,strcat,strcmp,strstr详解及模拟+strncpy,strncat,strncmp
weixin_65191470的博客
04-16 1156
strlen函数——测量字符串长度的函数 size_t strlen ( const char * str ); 1.字符串已经'\0'作为结束标志，strlen函数返回的是'\0'前面出现的字符个数，不包含‘\0’。 2.strlen返回值为size_t，无符号类型(注意） ...
字符函数和字符串函数详解（二）strncpy strncat strncmp strstr strtok（及其模拟实现）
C++领域内容分享
09-26 958
这一系列专门做c语言中的字符和字符串函数的使用教程，和常遇见的相关错误的原因和规避错误要注意的要点。（第二期：strncpy strncat strncmp strstr strtok）
验证子串（strncmp函数和strstr函数的应用）
Chris20021118的博客
01-11 456
题目描述 ： 输入两个字符串，验证其中一个串是否为另一个串的子串 输入格式： 输入两个字符串， 每个字符串占一行，长度不超过200200且不含空格。 输出格式： 若第一个串s1s1​是第二个串s2s2​的子串，则输出"(s1) is substring of (s2)"； 否则，若第二个串 s2是第一个串s1的子串，输出"(s2) is substring of (s1)"； 否则，输出"No substring"。 样例输入： abc dddncabca 样例输入：...
c语言常见字符串，strtok 函数的使用
weixin_50168448的博客
11-19 469
c语言常见字符串函数使用及实现 一、c的常见字符串函数： 头文件 #include<string.h> 1. 求串长：strlen(str) 求str长度（注意不包含‘\0’） 2. 串比较：strcmp(str1,str2)两串相同返回0，相反返回1。 3. 串复制：strcpy(str1, str2)将str2的内容复制给串1（包含’\0’） 4. 串连接：strcat(str1, str2)将str2接到str1后面 5. 找串中的字符：strstr( str, ch) ch是char类型
标准C库之strcpy，strncpy函数（拷贝C风格字符串、拷贝字符串，可指定拷贝长度）
最新发布
weixin_49503250的博客
04-26 1791
由于 strcpy 函数会继续复制超出源字符串的内存区域，可能会访问到非法的内存地址，导致未定义行为。未定义行为可能导致程序崩溃、数据损坏或其他不可预知的问题。为了避免这些问题，确保源字符串是一个 C 风格字符串。另外，可以使用更安全的字符串复制函数，例如 strncpy，它可以指定要复制的字符数，从而降低缓冲区溢出的风险。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值