C语言字符串函数与内存函数(附源码)

其他 2021-10-08 09:47:41 阅读次数: 0

浅析C语言字符串函数与内存函数（附源码）

本章内容我们介绍一些上面图中的库函数，将这些函数学好之后，在一些算法题中直接调用，可以节省很多时间哦！！！

进入正题之前，先推荐一个网站，可以去查阅C/C++的库函数：Cplusplus.com
源码：GitHub

话不多说，我们直接进入正题！

文章目录

一、字符串函数

1、strlen

//函数原型
#include <string.h>
size_t strlen ( const char * str );

注释： strlen函数是用来计算字符串的 长度 （单词 length）, 形参部分没得说，就是一个char*的指针， 特别注意的是这个返回值是size_t。

strlen函数计算的是字符串中字符的个数，我们都知道字符串的结束标志是**‘\0’**, 例如 ：

#include <stdio.h>
#include <string.h>
int main()
{
    
    
   char s1[] = "hello";

    printf("strlen:  %d\n",strlen(s1));
    printf("sizeof:  %d\n",sizeof(s1));
    
    return 0;
}

上面计算的结果如下：

大家一定要区别 strlen 与 sizeof 二者之间的区别，一个是计算字符串长度，另外一个是计算所占的空间大小，单位字节。

2、strcpy

#include <string.h>
char* strcpy( char *Destination, const char *Source );

注释： strcpy函数是用来 拷贝 字符串 (单词 copy)，形参部分： char* destination，目的地嘛， char* source，数据源地。就是将第二个指针指向的内存的数据拷贝到 第一个指针指向的内存空间。 返回值是一个char*，返回的就是拷贝之后，destination 的起始地址。

值得注意的几点是：

  • source 源字符串必须以 **’\0’**为结束。
  • 拷贝时，也会将source 里面的**’\0’**拷贝大destination里面去。
  • 目的地destination的空间必须足够大。
#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char dest[20] = "################";
	char src[10] = "hello";
	printf("拷贝之前: %s\n", dest);
	strcpy(dest, src);
	printf("拷贝之后: %s\n", dest);
	return 0;
}

运行结果如下：

3、strncpy

#include <string.h>
char* strncpy( char *Dest, const char *Source, size_t count );

注释： strncpy函数只是在strcpy函数的基础之上进行的完善，只是多了一个count参数，就是需要拷贝count个字符，具体的看代码：

#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char dest[20] = "################";
	char src[20] = "hello world";
	printf("拷贝之前: %s\n", dest);
	strncpy(dest, src, 5);
	printf("拷贝之后: %s\n", dest);
	return 0;
}

运行结果如下：

值得注意的是： 这里hello拷贝完之后，dest数组最开始的那些‘#’ 还是在的，因为在拷贝hello时，只是拷贝了这5个字符，并没有拷贝’\0’,所以在输入的时候，还是把最开始的那些‘#’，输出了。如果源字符串的长度小于count，则拷贝完源字符串之后，在目标的后边追加0，直到count个。

4、strcmp

#include <string.h>
int strcmp( const char *string1, const char *string2 );

注释： strcmp函数，就是用于 比较 两个字符串的大小。可能你就会有疑问，两个字符串怎么比大小？比长度？还是比什么？其实不然，是依次比较的两个字符串中每个字符的ASCII码值，例如： “a” 和“b”，字符a的ASCII码值是97，字符b的ASCII码值是98，所以“a” < "b"的。

标准规定如下：

  • 第一个字符串大于第二个字符串，则返回大于0的数字。
  • 第一个字符串小于第二个字符串，则返回小于0的数字。
  • 如果两个字符串相等，则返回数字0。

代码如下；

#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char s1[15] = "hello world";
	char s2[15] = "hello world";
	char s3[15] = "hello";
	int x1 = strcmp(s1, s2);
	int x2 = strcmp(s1, s3);
	printf("s1与s2: %d\n", x1); //相等
	printf("s1与s3: %d\n", x2); //大于
	return 0;
}

运行代码如下：

特别注意的是： strcmp函数比较的不是长度，而是从左到右依次比较每个字符的ASCII码值，例如下面代码，运行结果是多少？

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

int main()
{
    
    
    char s1[10] = "abcde";
    char s2[20] = "abcdf";
    int x = strcmp(s1,s2);
    printf("%d\n",x);
    return 0;
}

5、strncmp

#include <string.h>
int strncmp( const char *string1, const char *string2, size_t count );

注释： strncmp函数，跟strcmp函数差不多啊，换汤不换药的，只是在原函数的基础之上 进行了改善，多了一个count参数，也就是需要比较count个字符。

代码如下：

#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char s1[10] = "abcdef";
	char s2[10] = "abcdfg";
	int x1 = strncmp(s1, s2, 4); //比较前4个字符
	int x2 = strncmp(s1, s2, 6); //比较前6个字符
	printf("比较前4个字符: %d\n", x1); 
	printf("比较前6个字符: %d\n", x2);
	return 0;
}

运行结果如下：

6、strcat

#include <string.h>
char *strcat( char *Destination, const char *Source );

注释： strcat函数将source指向的数据 追加 到destination指向的内存空间的后面，例如：destination 指向的字符串是“C语言 “，source指针的字符串是”万岁“，追加之后的destination的内容就是”C语言万岁“。

值得注意的是；

  • source字符串必须以**’\0’** 结束。
  • destination指向的空间必须足够大。
  • destination必须是可修改的。
#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char dest[20] = "C语言 ";
	char src[10] = "万岁";
	printf("追加之前: %s\n", dest);
	strcat(dest, src);
	printf("追加之后: %s\n", dest);
	return 0;
}

运行代码如下：

7、strncat

#include <string.h>
char *strncat( char *strDest, const char *strSource, size_t count );

注释： strncat函数，也是在strcat函数的基础之上进行了完善，加入了参数count，追加count个字符。代码如下：

#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char dest[20] = "我会信你吗？";
	char src[20] = "我信你个鬼";
	printf("追加之前: %s\n", dest);
	strncat(dest, src, 4); //为什么是4
	printf("追加之后: %s\n", dest);
	return 0;
}

运行代码如下：

这里提醒一下，拷贝的为什么是4个字节？？

因为一个汉字占2个字节哦。

8、strtok

#include ,string.h>
char *strtok( char *strToken, const char *strDelimit );

注释： strtok函数，用于分隔字符串的，例如：“hello&world”，如果strDelimit的字符串是“&”，则strtok函数，会以&为分界线，将hello分隔成一个字符串，将world分隔成一个字符串。

值得注意的是；

  • strDelimit参数是个字符串，定义了用作分隔符的字符集合。

  • 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

  • strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改

    变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

  • strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

  • strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

  • 如果字符串中不存在更多的标记，则返回 NULL 指针。

#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char strToken[20] = "http:www.baidu.com";
	char strDelimit[10] = "/:.";
	printf("分隔之前: %s\n",strToken);
	char* tmp = strtok(strToken, strDelimit);
	printf("分隔得到的字符串: %s\n", tmp);
	printf("分隔之后: %s\n", strToken);
	return 0;
}

运行代码如下：

看上面的图，我们发现，分隔之后，原来的字符串被破坏了，所以在使用strtok函数的时候，都是先拷贝一份临时，去操作这个临时的字符串，才不会对原来的字符串带来破坏。

但其实，strtok函数，一般不是这样使用的，如下使用：

#include <stdio.h>
#include <string.h>
int main()
{
    
    
	char strToken[20] = "http:www.baidu.com"; //本来还有 //的，因为考虑到转义字符，这里我就省略了
	char string[20] = {
    
     0 };
	char* tmp = NULL;
	char strDelimit[10] = "/:.";
	strcpy(string, strToken); //先拷贝一份临时的
    //第一次使用strtok函数，第一个参数需要传入被分隔的字符串，第二次调用时，直接给NULL也可以，因为函数会自动保存上次分隔之后的下一个字符串的位置
	for (tmp = strtok(string, strDelimit); tmp != NULL; tmp = strtok(NULL, strDelimit))
		printf("分隔得到的字符串: %s\n", tmp);
	
	return 0;
}

运行代码如下：

9、strerror

#include <string.h>
char *strerror( int errnum );

注释： strerror函数，是用来 解码 错误码的。每一个错误码，对应的就是一些错误信息，在我们写代码的过程中，难免遇到一些未知的错误，此时这个函数就可以将系统返回的错误码，用strerror函数进行解码，翻译为中文的文字信息，具体的看下面的代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
int main()
{
    
    
	FILE* fp = fopen("test.txt", "r"); //以读取的形式打开test.txt文本文件
	printf("%s\n", strerror(errno)); 
	return 0;
}

运行的代码如下：

因为是以只读的形式去打开test.txt文件，如果文件路径中没有这个文件，就会报错。errno就是获取错误码。

相应的还有函数： perror，这个用起来，比strerror更为简单一下，这里的char* string指针，只需要自己输入是什么错误即可，会自动在显示器输出相应的文字说明。

//void perror( const char *string );
int main()
{
    
    
	FILE* fp = fopen("test.txt", "r"); //以读取的形式打开test.txt文本文件
	//printf("%s\n", strerror(errno)); 
	perror("打开文件 ");
	return 0;
}

10、strstr

#include <string.h>
char* strstr( const char *string, const char *strCharSet );

注释： 在char* string指向的字符串里查找 char* strCharSet指向的字符串，也就是说，在第一个形参里面查找第二次形参里面的字符串，有的话，就返回这个子串在第一个形参里面的位置。

#include <string.h>
#include <stdio.h>
int main()
{
    
    
   char str[] =    "lazy";
   char string[] = "The quick brown dog jumps over the lazy fox";
   char fmt1[] =   "         1         2         3         4         5";
   char fmt2[] =   "12345678901234567890123456789012345678901234567890";
   char *pdest;
   int  result;
   printf( "String to be searched:\n\t%s\n", string );
   printf( "\t%s\n\t%s\n\n", fmt1, fmt2 );
   pdest = strstr( string, str );
   result = pdest - string + 1;
   if( pdest != NULL )
      printf( "%s found at position %d\n\n", str, result );
   else
      printf( "%s not found\n", str );
    return 0;
}

运行结果如下：

这个函数，在学校教材的练习题中，经常用到。经常用到查找子串。

二、内存函数

1、memcpy

#include <string.h>
void *memcpy( void *dest, const void *src, size_t count );

注释： 从sre指向的数据，拷贝count个，到dest指向的内存空间里面去。

值得注意的是：

  • 这个函数在遇到 ‘\0’ 的时候并不会停下来。
  • 如果src和dest有任何的重叠，复制的结果都是未定义的。
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
int main()
{
    
    
	int arr1[20] = {
    
     1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = {
    
     3,3,3,3,3,4,4,4,4,4 };
	int i = 0;
	printf("拷贝前\n");
	for (i = 0; i < 10; i++)
		printf("%d ", arr1[i]);

	memcpy(arr1, arr2,20); //20 ，指的是20个字节

	printf("\n拷贝后\n");
	for (i = 0; i < 10; i++)
		printf("%d ", arr1[i]);

	return 0;
}

运行代码如下:

特别注意的是，第三个形参count的单位是字节

2、memmove

#include <strimg.h>
void *memmove( void *dest, const void *src, size_t count );

注释： memmove和memcpy很相似，一个是拷贝，一个是移动。

  • 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
  • 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
int main () 
{
    
     
 char str[] = "memmove can be very useful......"; 
 memmove (str+20,str+15,11);  //移动了very
 puts (str); 
 return 0; 
}

运行结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-01b9yrZk-1624119189503)(asserts/image-20210619234554098.png)]

3、memcmp

#include <strimg.h>
int memcmp( const void *buf1, const void *buf2, size_t count );

注释： 在内存中进行比较，从buf2和buf1开始比较count个字节的空间内容。

返回值和strcmp一样。

  • 第一个字符串大于第二个字符串，则返回大于0的数字。
  • 第一个字符串小于第二个字符串，则返回小于0的数字。
  • 如果两个字符串相等，则返回数字0。
#include <string.h>
#include <stdio.h>

int main()
{
    
    
   char first[]  = "12345678901234567890";
   char second[] = "12345678901234567891";
   int result;

   printf( "Compare '%.19s' to '%.19s':\n", first, second );
   result = memcmp( first, second, 19 );
   if( result < 0 )
      printf( "First is less than second.\n" );
   else if( result == 0 )
      printf( "First is equal to second.\n" );
   else if( result > 0 )
      printf( "First is greater than second.\n" );
    return 0;
}

运行结果如下：

前19个字符的内容是一样的，当去比较第20个字节的内容时，一个是1，一个是0，肯定不相当的。如下：

#include <string.h>
#include <stdlib.h>
#inlcude <stdio.h>
int main()
{
    
    
    char first[] = "12345678901234567890";
    char second[] = "12345678901234567891";
    int result;

    printf("Compare '%.19s' to '%.19s':\n", first, second);
    result = memcmp(first, second, 20);
    if (result < 0)
        printf("First is less than second.\n");
    else if (result == 0)
        printf("First is equal to second.\n");
    else if (result > 0)
        printf("First is greater than second.\n");
    return 0;
}

4、memset

#include <string.h>
void *memset( void *dest, int c, size_t count );

注释： 将缓冲区设置为指定的字符。dest为目的地，int c为具体的字符， count为 设置多个字节的空间。

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
int main()
{
    
    
	char buffer[] = "This is a test of the memset function";

	printf("Before: %s\n", buffer);
	memset(buffer, '*', 4); //设置为 * 
	printf("After:  %s\n", buffer);

	return 0;
}

运行代码如下：

值得注意的是，这个memset，只能一个字节一个字节的设置，例如在 int类型的数值中，我想全部设置数据为10，这个是做不到的，要么就是每个字节的空间设置为一样的字符。

本期更新到此结束啦，下期见！！！

<string.h>
void *memset( void *dest, int c, size_t count );


注释： 将缓冲区设置为指定的字符。dest为目的地，int c为具体的字符， count为 设置多个字节的空间。

~~~c
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
int main()
{
	char buffer[] = "This is a test of the memset function";

	printf("Before: %s\n", buffer);
	memset(buffer, '*', 4); //设置为 * 
	printf("After:  %s\n", buffer);

	return 0;
}

运行代码如下：

值得注意的是，这个memset，只能一个字节一个字节的设置，例如在 int类型的数值中，我想全部设置数据为10，这个是做不到的，要么就是每个字节的空间设置为一样的字符。

本期更新到此结束啦，下期见！！！

猜你喜欢

转载自blog.csdn.net/x0919/article/details/118061266
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022