C语言学习（4）——字符串和内存

最新推荐文章于 2024-07-15 19:39:34 发布
最新推荐文章于 2024-07-15 19:39:34 发布
阅读量1k 收藏 5
点赞数 2
分类专栏： C学习 文章标签： c语言 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LingeXXHuaye/article/details/110089415
版权

一、C语言中的内存分布区

1）BSS段（bss segment）：常是指用来存放程序中未初始化的全局变量的一块内存区域。

2）数据段（data segment）：用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。

3）代码段（code segment/text segment）: 用来存放程序执行代码的一块内存区域。这部分区域的代码属于只读。在代码段中，字符串常量也属于这部分。

4）堆（heap）：堆是用于存放进程运行中被malloc和free动态分配的内存段，它的大小并不固定，可动态扩张或缩减。

5）栈(stack)：栈又称堆栈，存放程序的局部变量除此以外，在函数被调用时，栈用来传递参数和返回值等。由于栈的先进后出特点，所以栈特别方便用来保存/恢复调用现场。

内存操作函数:

1）memset()

void *memset(void *s, int c, size_t n);

功能：将s的内存区域的前n个字节以参数c填入

参数：s：需要操作内存s的首地址

           c：填充的字符，c虽然参数为int，但必须是unsigned char , 范围为0~255

           n：指定需要设置的大小

返回值：s的首地址

#include <stdio.h>
int main()
{
	int a[10];
	memset(a, 97, sizeof(a));  //97对应'a'
	memset(a, 98, sizeof(a)-sizeof(int)*5); //98对应'b',
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%c ", a[i]);
	}
}

执行结果：b b b b b a a a a a

2）memcpy()

void *memcpy(void *dest, const void *src, size_t n);

功能：拷贝src所指的内存内容的前n个字节到dest所值的内存地址上。

参数：dest：目的内存首地址

           src：源内存首地址，注意：dest和src所指的内存空间不可重叠，可能会导致程序报错

           n：需要拷贝的字节数

返回值：dest的首地址

#include <stdio.h>
int main()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int b[10];
	memcpy(b, a, sizeof(a));
	for (int i = 0; i < 10; i++)
	{
		printf("%d, ", b[i]);
	}
}

执行结果：b b b b b a a a a a

可能出现的情况：

  • dest的长度小于n的字节数，出现报错
  • dest和src所指的内存空间存在内存重叠​​​​​​，导致没法得出自己想要的结果

3）memmove()

memmove()功能用法和memcpy()一样，区别在于：dest和src所指的内存空间重叠时，memmove()仍然能处理，不过执行效率比memcpy()低些。

2种内存重叠方式：

这第1种内存重叠方式中，memcpy和memmove得到的结果是一样的；但在第2种内存重叠方式中，memcpy无法得到正确的结果。接下来看看他们的具体实现：

void *memcpy(void *dst,void *src,size_t n)
{
     char *tmp = (char *)dst;
     char *p = (char *)src;  
     while(n--)
     {
          *tmp++ = *p++;      //从前往后复制
     }
     return dst;
}

void *my_memmove(void *dst,void *src,size_t n)
{
   char *p1 = (char *)dst;
   char *p2 = (char *)src;
   if(p1 > p2 && p2+n > p1)  //对于第二种内存覆盖进行了讨论
   {
       p1 = p1+n-1;
       p2 = p2+n-1; 
       while(n--)
       {
          *p1-- = *p2--;    //从后往前复制
       }
   }
   else
   {
       while(n--)
       {
          *p1++ = *p2++;    //从前往后复制
       }
   }
  return dst;
}

从具体实现我们可以知道，当出现第1种内存重叠时，memcpy和memmove都是从前往后复制，因此不会影响结果。但是出现第2种内存重叠时，从前往后复制的话就会出现问题，原本src末尾的一些数据会丢失，因此memmove对memcpy进行了改进，增加了这一种情况出现时的做法：从后往前复制。这就是memmove比memcpy多的一个考虑点，所以说，在实际使用时，使用memmove是比memcpy更安全的。

在这里插入图片描述

【疑惑】在VS2017中使用这两个函数进行实验时发现他们竟然没有区别，希望有大佬可以告诉我是为什么...

4) memcmp()

int memcmp(const void *s1, const void *s2, size_t n);

功能：比较s1和s2所指向内存区域的前n个字节

参数：s1：内存首地址1

          s2：内存首地址2

          n：需比较的前n个字节

返回值：相等：=0

              大于：>0

              小于：<0

#include <stdio.h>
#include <string.h>;
int main()
{
	int a[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	int b[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

	int flag = memcmp(a, b, sizeof(a));
	printf("flag = %d\n", flag);
}

执行结果：flag = 0

假设使用上述代码，只改变a和b的值，注意以下代码和返回结果：

int a[10] = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int b[10] = { 0, 1, 5, 6, 7, 8, 9, 1, 2, 3 };
//执行结果：flag=1

int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int b[10] = { 1, 2, 5, 0, 0, 0, 0, 0, 0, 0  };
//执行结果：flag=-1

char a[] = "accdefg";
char b[] = "abcdefg";
//执行结果：flag=1

char a[] = "abcdefg";
char b[] = "acaaaaa";
//执行结果：flag=-1

可以看出，在两个数组中元素的逐个比较时，最先出现更大数的数组比另外一个数组大。

二、指针与字符串

#include<stdio.h>
int main()
{
	char *s1="abcde";
	char s2[]={"abcde"};
	printf("%s,%c%s,%c\n",s1,*s1,s1+1,s1[1]);  //注意当输出一个字符串时使用的是指针
	printf("%s,%c,%s,%c\n",s2,*s2,s2+1,s2[1]); //输出一个字符时使用的是对指针的解引用
	return 0;
}

运行结果为：

abcde,a,bcde,b

abcde,a,bcde,b

由此可见，字符数组和字符指针在使用上是相似的。但是两者又是有区别的：

字符指针

字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以 \0 作为串的结束。

#include <stdio.h>
int main(void)
{  
    char *a= "abcd" ;  
    printf("输出字符：%c,", *a);      //输出字符，使用"%c"
    printf("输出字符串：%s", a);     //输出字符串，使用"%s"
}

运行结果为：

输出字符：a, 输出字符串：abcd

【注意】：字符指针a所指向的地址为存放在代码段中的字符串常量，该内存区域只可读不可写。

字符数组

字符数组是由若干个数组元素组成的，它可用来存放整个字符串（即用字符数组来存放字符串）。在C语言中，将字符串作为字符数组来处理（c++中不是）。

在C中：

在C++中：

初始化方式：

在C中一个字符串的结束标志为'\0'，在平时常见的字符串如“I am a string”中末尾会默认添加一个'\0'。

char str[]={"hello"};    //正确赋值，系统自动加入\0
char str[]="hello";      //正确赋值，系统自动加入\0
char str[]={'h','e','l','l','o','\0'}     //正确赋值,但使用该方式时记得要给字符串留足够的位置存放'\0'

//下面是错误的使用方式（整体赋值只能出现在字符数组初始化时使用）
char str[20];
str="hello";

总结：

char str1[] = {'h', 'i', '\0'};    //变量，可读可写
char str2[] = "hi";                //变量，可读可写
char *str3 = "hi";                 //变量，可读不可写，str3指向字符串常量“hi”中首字符的地址
char *str4 = {'h', 'i', '\0'};     //错误赋值方式

因此，C语言中使用字符指针和字符数组都是可以用来表示和存放字符串的。

三、字符串处理函数

1）strcpy()

char *strcpy(char *dest, const char *src);

功能：把src所指向的字符串复制到dest所指向的空间中，'\0'也会拷贝过去

参数：dest：目的字符串首地址

           src：源字符首地址

返回值：成功：返回dest字符串的首地址

              失败：NULL

如果参数dest所指的内存空间不够大，可能会造成缓冲溢出的错误情况。

char dest[20] = "123456789";
char src[] = "hello world";
strcpy(dest, src);
printf("%s\n", dest);
//执行结果
hello world

2）strncpy()

char *strncpy(char *dest, const char *src, size_t n);

功能：把src指向字符串的前n个字符复制到dest所指向的空间中，是否拷贝结束符看指定的长度是否包含'\0'。

参数：dest：目的字符串首地址

           src：源字符首地址

           n：指定需要拷贝字符串个数

返回值：成功：返回dest字符串的首地址

              失败：NULL

char dest[20] ;
char src[] = "hello world";
strncpy(dest, src, 5);//拷贝了五个字符过去，不包含字符串末尾'\0'
printf("%s\n", dest)；//输出该字符串时因为没有末尾'\0',后面会有乱码出现
dest[5] = '\0';
printf("%s\n", dest);
//执行结果
hello烫烫烫烫烫烫烫烫烫汰觠玷?
hello

3）strcat()

char *strcat(char *dest, const char *src);

功能：将src字符串连接到dest的尾部，‘\0’也会追加过去

参数：dest：目的字符串首地址

           src：源字符首地址

返回值：成功：返回dest字符串的首地址

              失败：NULL

char str[20] = "123";     //目的字符串空间一定要足够
char *src = "hello world";//不然在用该函数时会出现错误
printf("%s\n", strcat(str, src));
//执行结果
123hello world

4）strncat()

char *strncat(char *dest, const char *src, size_t n);

功能：将src字符串前n个字符连接到dest的尾部，‘\0’也会追加过去

参数：dest：目的字符串首地址

          src：源字符首地址

          n：指定需要追加字符串个数

返回值：成功：返回dest字符串的首地址

              失败：NULL

char str[20] = "123";
char *src = "hello world";
printf("%s\n", strncat(str, src, 5));//会自动把'\0'添加过去，因此不会乱码
//执行结果
123hello

5）strcmp()

int strcmp(const char *s1, const char *s2);

功能：比较 s1 和 s2 的大小，比较的是字符ASCII码大小。

参数：s1：字符串1首地址

           s2：字符串2首地址

返回值：相等：0

              大于：>0 在不同操作系统strcmp结果会不同   返回ASCII差值

              小于：<0

char *str1 = "hello world";
char *str2 = "hello wozzlzdppp"; //在每个字符逐个比较的过程中，最先出现更大字符的字符串大
if (strcmp(str1, str2) == 0)
{
	printf("str1==str2\n");
}
else if (strcmp(str1, str2) > 0)
{
	printf("str1>str2\n");
}	
else
{
	printf("str1<str2\n");
}
//执行结果
str1>str2

6）strncmp()

int strncmp(const char *s1, const char *s2, size_t n);

功能：比较 s1 和 s2 前n个字符的大小，比较的是字符ASCII码大小

参数：s1：字符串1首地址

          s2：字符串2首地址

          n：指定比较字符串的数量

返回值：相等：0

              大于： > 0

char *str1 = "hello world";
char *str2 = "hello wozzlzdppp"; 
if (strncmp(str1, str2, 5) == 0)
{
	printf("str1==str2\n");
}
else if (strcmp(str1, str2) > 0)
{
	printf("str1>str2\n");
}	
else
{
	printf("str1<str2\n");
}
//执行结果
str1=str2

7）sprintf()

int sprintf(char *str, const char *format, ...);

功能：根据参数format字符串来转换并格式化数据，然后将结果输出到str指定的空间中，直到出现字符串结束符 '\0'  为止。

参数：str：字符串首地址

           format：字符串格式，用法和printf()一样

返回值：成功：实际格式化的字符个数

              失败： - 1

char dst[100] = { 0 };
int a = 10;
char src[] = "hello world";
printf("a = %d, src = %s", a, src);
printf("\n");

int len = sprintf(dst, "a = %d, src = %s", a, src);	
printf("dst = \" %s\"\n", dst);
printf("len = %d\n", len);
//执行结果
a = 10, src = hello world
dst = " a = 10, src = hello world"
len = 25

8）sscanf()

int sscanf(const char *str, const char *format, ...);

功能：从str指定的字符串读取数据，并根据参数format字符串来转换并格式化数据。

参数：str：指定的字符串首地址

           format：字符串格式，用法和scanf()一样

返回值：成功：参数数目，成功转换的值的个数

              失败： - 1

char src[] = "a=10, b=20";
int a;
int b;
sscanf(src, "a=%d,  b=%d", &a, &b);
printf("a:%d, b:%d\n", a, b);
//执行结果
a:10， b:20

9）strchr()

char *strchr(const char *s, int c);

功能：在字符串s中查找字母c出现的位置，查找一个字符

参数：s：字符串首地址

           c：匹配字母(字符)

返回值：成功：返回第一次出现的c地址

              失败：NULL

char src[] = "ddda123abcd";
char *p = strchr(src, 'a');
printf("p = %s\n", p);
//执行结果
a123abcd

10）strstr()

char *strstr(const char *haystack, const char *needle);

功能：在字符串haystack中查找字符串needle出现的位置，查找一个字符串

参数：haystack：源字符串首地址

           needle：匹配字符串首地址

返回值：成功：返回第一次出现的needle地址

              失败：NULL

char src[] = "ddddabcd123abcd333abcd";
char *p = strstr(src, "abcd");
printf("p = %s\n", p);
//执行结果
p = abcd123abcd333abcd

11）strtok()

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

功能：来将字符串分割成一个个片段。当strtok()在参数s的字符串中发现参数delim中包含的分割字符时, 则会将该字符改为\0 字符，当连续出现多个时只替换第一个为\0。

参数：str：指向欲分割的字符串

           delim：为分割字符串中包含的所有字符

返回值：成功：分割后字符串首地址

              失败：NULL

  • 在第一次调用时：strtok()必需给予参数s字符串
  • 往后的调用则将参数s设置成NULL，每次调用成功则返回指向被分割出片段的指针
char a[100] = "adc*fvcv.ebcy*hghbdfg$casdert";
char *s = strtok(a, ".*$");//将'.'，'*','$'分割的子串取出
while (s != NULL)
{
	printf("%s\n", s);
	s = strtok(NULL, ".*$");//将'.'，'*','$'分割的子串取出	
}
//执行结果
adc
fvcv
ebcy
hghbdfg
casdert

12）atoi()

#include <stdlib.h>

int atoi(const char *nptr);

功能：atoi()会扫描nptr字符串，跳过前面的空格字符，直到遇到数字或正负号才开始做转换，而遇到非数字或字符串结束符('\0')才结束转换，并将结果返回返回值。

参数：nptr：待转换的字符串

返回值：成功转换后整数

  • atof()：把一个小数形式的字符串转化为一个浮点数。
  • atol()：将一个字符串转化为long类型
char str1[] = "          -10";
int num1 = atoi(str1);
printf("num1 = %d\n", num1);

char str2[] = "0.123";
float num2 = atof(str2);
printf("num2 = %f\n", num2);

char str3[] = "123L";
long num3 = atol(str3);
printf("num3 = %ld\n", num3);
//执行结果
num1 = -10
num2 = 0.123000
num3 = 123

LingeLee
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
阿里面试题：一个 String 字符串占多少内存？
xmt1139057136的专栏
12-29 1万+
最近一个网友问我，在面试阿里的时候，被问到了一个 String 字符串占用多少内存的问题？他当时懵了，因为他只记得基本数据类型占用的空间大小。说实话，这个问题，如果是我，我也可以会回答错...
C语言中字符串的内存地址操作的相关函数简介
09-03
主要介绍了C语言中字符串的内存地址操作的相关函数,包括bcopy()函数和bzero()函数以及bcmp()函数,需要的朋友可以参考下
c语言中的字符串函数以及内存函数
weixin_59093392的博客
05-10 80
可以对目标处的字符串进行追加，追加内容为source地址处到下一个 '\0' 处，包含在string.h的头文件里。包含在string.h的头文件里。前面说了字符串操作函数，就是操作字符串的各种函数，那内存操作函数，就是操作内存中的数据的一些函数了，这些函数可以不用管操作的对象类型，不管是字符，还是整数，还是浮点数，都可以对其就行拷贝，对比，移动等的操作。str：被分割的源字符串，如果此参数为空，那就将返回上一个未分割完的字符串再次被标记分割的地址，如果参数为空，上一个字符串也被分割完，那就返回NULL；
C#中字符串的内存分配与暂存池【非常详细】
xiaouncle的博客
02-20 7952
一、学会查看变量的内存地址 想要研究C#中字符串的内存分配情况，如果能查看字符串的内存地址就好了。其实我们可以在VS2017中查看变量的内存地址，截图中有详细说明： 二、string类型简单说明 string是引用类型的，在C#中引用类型的内存分配在托管堆（堆内存）上。string不支持以下两种创建方式： string str01 = "heng"; //错误创建方法1 strin...
c语言中字符串地址符,C++_C语言中字符串的内存地址操作的相关函数简介，C语言bcopy()函数：复制内存(字 - phpStudy...
weixin_42110362的博客
05-17 957
C语言中字符串的内存地址操作的相关函数简介C语言bcopy()函数：复制内存(字符串)头文件：#include bcopy() 函数用来复制内存(字符串)，其原型为：void bcopy(const void *src, void *dest, int n);【参数】src 为源内存块(字符串)指针，dest 为目标内存块(字符串)指针，n 为要复制的内存(字符串)的前 n 个字节长度。bcopy...
C语言知识梳理——字符串与内存函数
暗中观察的咸鱼的博客
04-11 744
C语言知识梳理——字符串与内存函数前言字符串函数1、长度不受限制的字符串函数strlenstrcpystrcatstrcmp2、长度受限制的字符串函数strncpystrncatstrncmp3、字符串查找函数strstrstrtok4、错误信息报告函数strerror内存函数memcpymemmovememcmpmemset 前言 C语言的学习离不开各种库函数的运用，例如：字符串函数中的strlen、strcpy；内存函数中的memcpy、memmove……本文就常见的字符串函数与内存函数展开，介绍各函数
C语言学习笔记——字符串和字符串函数（一）
m0_47773954的博客
05-25 274
一、字符串 由于字符串比较常用，所以C提供了许多用于处理字符串的函数，下面的例子简单介绍一下表示字符串的几种方式。 例; #incldue<stdio.h> #define MESSAGE "I am a symbolic string constant." #define MAXLENTH 100 int main(void){ char string[MAXLENTH]="I am a string in array."; const char *p1="Someting is
c语言实现字符串分割strsplit.c
10-17
注 意：存储分割后的子字符串列表的变量str_list是用动态内存分配函数malloc分配的，在使用完str_list后要及时释放其所占用的内存。 ———————————————— 版权声明：本文为CSDN博主「logan_lei」的原创...
删除字符串中的a，A——C语言代码
05-22
在C语言中，删除字符串中的特定字符是一项基本操作，它涉及到字符数组的处理和字符串的遍历。在本例中，任务是删除一个字符串中所有的'a'和'A'字符。以下是一个详细的步骤介绍： 首先，我们需要理解C语言中的字符串...
2021-11-22 C语言学习应用——用C语言实现大数相乘（csdn）————程序.pdf
12-01
标题中的“2021-11-22 C语言学习应用——用C语言实现大数...总之，这篇教程详细介绍了如何用C语言实现大数相乘，涉及了字符串处理、数组操作、循环和进位计算等基本编程概念，对初学者理解大数运算有很好的指导作用。
单片机课程设计——字符串函数string.h应用举例.zip
09-21
通过这个课程设计，你可以掌握如何在C语言环境中编写针对单片机的字符串处理代码，了解`string.h`库的实用性和效率，并且学习如何将这些代码转换为实际的硬件操作。同时，这也是一次实践单片机编程、调试和烧录过程...
C语言课程设计——图书管理系统.zip
06-13
C语言中的`strlen`、`strcpy`、`strcat`、`strcmp`等函数会派上用场，用于处理和比较字符串。 5. **错误处理**：在编程过程中，错误处理是必不可少的部分。你需要使用`if`语句和错误代码来检测并处理可能出现的问题...
[正式学习java③]——字符串在内存中的存储方式、为什么字符串不可变、字符串的拼接原理，键盘录入的小细节。
Panci_的博客
10-18 1697
🔥在java中，内存中有两个地方可以存储字符串，一个是字符串池，一个是堆内存，串池中的字符串不会重复，而堆中的字符串每次都会开辟一块新的空间，因为维护串池的是一个hashtable，以字符串hashcode作为建，引用作为值。字符串的底层是用一个字符数组保存的，而这个字符数组又是用final和private关键字修饰的，用final关键字修饰代表该数组的地址不能发生变化，但是你可以修改数组里面的内容啊，这时private发挥作用了，限制这个数组只能在String类中使用，你压根拿不到这个地址。
Java的String字符串内存布局知多少？
开心的博客
09-26 555
1. 初始化 public static void main(String[] args) { String str1 = "hello"; String str2 = new String("hello"); char[] chars = {'h', 'e', 'l', 'l', 'o'}; String str3 = new String(chars); } 仔细观察 str3 的创建过程 分析 new String(chars) 源码
字符串在内存中的存储方式
weixin_50212958的博客
10-26 3949
字符串在内存中的存储方式 连续的空间，整个数组的大小是元素个数*元素类型大小 整形数组； int a[3]={1,2,3}; // 连续的空间，整个数组的大小是元素个数*元素类型大小 printf("a数组的大小是；%d\n",sizeof(a)); printf("a数组的大小是；%d\n",sizeof(a[0])); printf("a数组的大小是；%d\n",sizeof(int)); printf("数组的个数可以这么算，结果是；%d\n",sizeof(a)/s
char src[]与char *src的区别
xinianbuxiu的博客
07-21 2082
char*src = "hello" 中的a是指向第一个字符‘a'的一个指针 charsrc[20] = "hello" 中数组名a也是执行数组第一个字符‘h’的指针 但二者并不相同： 看实例：把两个字符串相加： 运行结果为： 把字符串加到指针所指的字串上去，出现段错误，本质原因：*d存放在常量区，是无法修的。而数组是存放在栈中，是可以修改的。两者区别如下： 一.
C# string字符串内存管理深入分析（全程干货）
游戏码农一枚，不定时分享技术文章~
09-07 3298
C# string字符串内存管理深入分析（全程干货）
C语言之传值、传址详解
十三阿哥的博客
06-15 1910
C语言传值、传址详解
[C/C++入门][循环]14、计算2的幂(2的n次方）
最新发布
qq_14840819的专栏
07-15 917
计算2的幂（即2的n次方）非常经典。你懂几种方法呢？很多人只会一种，我们来分析一下。
C语言编程：字符数组与字符串引用详解
在字符数组和字符串的部分，教材提到了输入字符串后，数组会自动添加一个结束标志`\0`，表示字符串的结束。同时，教材指出，字符数组可以用来存储字符串，但不能直接通过整体赋值的方式来初始化，必须通过逐个字符...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值