结构体,堆空间

￡神魔★判官ぃ 2022-11-28 13:44 173阅读 0赞

一、堆空间的申请与释放。  
1、堆空间的特点。  
堆区不像栈区一样，通过申请变量而得到，而是通过写代码调用malloc()函数而得到。

代码中定义局部变量 -> 等价于在栈区申请空间。  
代码中定义全局变量 -> 等价于在bss/data区申请空间。  
代码中出现了常量"hello" -> 等价于在rodata区申请空间。  
代表中调用malloc函数 -> 等价于在堆区申请。

2、如何申请堆空间？如何释放释放空间？  
堆空间必须主动申请，主动释放，也就是说在函数中申请了栈区和堆区的空间，在函数返回时，只有栈区的空间会自动释放，堆区空间是不会释放，除非你主动释放。

1）申请空间。 -> malloc() -> 查看用法： man 3 malloc  
函数功能： allocate dynamic memory  
//申请堆空间

使用格式：  
头文件： \#include <stdlib.h>  
原型：void \*malloc(size\_t size);

参数：  
size： 需要申请的堆空间的总字节数

返回值：  
成功： a pointer to the allocated memory. -> 堆空间的地址 (void \*)  
失败： NULL （NULL = malloc(0)）

注意：  
这个堆区的空间申请下来后，因为系统不知道你申请的空间是来放什么数据的，所以地址的类型是void \*,我们用户使用堆区空间，就必须先强制转换类型。

2）主动释放。 -> free() -> man 3 free  
函数功能： free dynamic memory  
//释放堆空间  
使用格式：  
头文件： \#include <stdlib.h>  
原型： void free(void \*ptr);

参数：  
ptr： 需要释放的空间的地址。（其实就是malloc函数的返回值）

返回值：无。

例题： 申请一块堆空间，用于存放一个整型数据，赋值一个100给这片内存空间，然后释放该该空间。

\#include <stdlib.h>  
\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int \*p = (int\*)malloc(4);  
\*p = 100;  
printf("%d\\n",p\[0\]); //p\[0\] = \*(p+0) = \*p  
  
free(p);  
return 0;  
\}  
结果：100

练习1： 申请了堆空间后，初始值是多少？ -> 0

\#include <stdio.h>  
\#include <stdlib.h>

int main(int argc,char \*argv\[\])  
\{  
int \*p = (int \*)malloc(sizeof(int)\*3);  
printf("p\[0\] = %d\\n",p\[0\]);  
printf("p\[1\] = %d\\n",p\[1\]);  
printf("p\[2\] = %d\\n",p\[2\]);  
free(p);  
return 0;  
\}

练习2： 在一个自定义函数中申请堆空间，看看函数返回之后，这个堆空间还在不在。

\#include <stdio.h>  
\#include <stdlib.h>

int \*fun(int x) //自定义函数  
\{  
int \*p = (int \*)malloc(4);  
p\[0\] = x;  
return p;  
\}

int main(int argc,char \*argv\[\])  
\{  
int data = 100;  
int \*p = fun(data); //p依然指向这片内存，这片内存由于是堆，所以没有释放。  
printf("p\[0\] = %d\\n",p\[0\]); //100  
  
free(p); -> 当你使用完堆之后，就要主动释放。  
return 0;  
\}

练习3： 堆空间释放后，还可以使用吗？如果使用会怎么样？ -> 可以，但是有可能就不是之前的那些值。

\#include <stdio.h>  
\#include <stdlib.h>

int \*fun(int x) //自定义函数  
\{  
int \*p = (int \*)malloc(4);  
p\[0\] = x;  
free(p); -> 释放掉之后，再去访问它，有可能数据已经被别人改过。  
return p;  
\}

int main(int argc,char \*argv\[\])  
\{  
int data = 100;  
int \*p = fun(data);  
printf("p\[0\] = %d\\n",p\[0\]); //随机值  
return 0;  
\}

总结：  
堆空间一直都在

1）当你malloc一片堆空间。 变化： 这片堆空间从不属于你变成属于你。

堆空间一直都在

2）你可以随意访问这片堆空间。

堆空间一直都在

3）当你free一片堆空间。 变化： 这片堆空间属于你变成不属于你。

堆空间一直都在

4）你还是可以访问这片堆空间，但是这片堆空间由于不属于你，所以堆空间上的值是随机值。

3、易错点。  
1）char A\[10\] = "hello";  
strcpy(A,"world");  
正确，在内存空间上，连续申请10个字节，然后使用变量A间接访问这片内存空间，然后将常量区的"hello"这个字符串拷贝到变量A代表的那片空间。  
然后再常量区的"world"拷贝到变量A所代表的那片空间上。

2）char A\[10\] = "hello";  
A = "world";

在内存空间上，连续申请10个字节，然后使用变量A间接访问这片内存空间，然后将常量区的"hello"这个字符串拷贝到变量A代表的那片空间。  
错误，数组名A是一个常量，所有不能对数组A赋值。

3）char \*p = "hello";  
strcpy(p,"world");

在内存空间上，连续申请8个字节，然后使用变量p间接访问这片内存空间，将常量区的"hello"字符串首元素的地址存储到变量p所代表的那片空间上。  
错误，因为p指向常量区的'h'，是指向一个常量。所以strcpy()是将"world"拷贝到p指向的空间，因为p指向的空间是常量区，所以等价于给常量区赋值，所以发生段错误。

4）char \*p = "hello";  
p = "world";

正确，在内存空间上，连续申请8个字节，然后使用变量p间接访问这片内存空间，将常量区的"hello"字符串首元素的地址存储到变量p所代表的那片空间上。  
将常量区中"world"字符串的首元素'w'的地址储存到变量p所代表的那片空间上。

5）char A\[10\] = \{0\};  
char \*p = A;  
strcpy(p,"hello");

正确，连续申请10个字节，然后使用变量A间接访问这片内存空间，然后将常量区的"hello"这个字符串拷贝到变量A代表的那片空间，然后将空间清零。  
在内存空间中，连续申请8个字节，然后使用变量p间接访问这片内存空间，将数组A首元素的地址赋值给变量p所代表的那片内存空间上。  
然后再将常量区的"hello"拷贝到变量p的中值所代表的那片空间上。

6）char \*p = malloc(sizeof(char)\*10);  
p = "hello";

正确，在内存空间上，连续申请8个字节，然后使用变量p间接访问这片内存空间，然后在堆区中连续申请10个字节，然后把堆区的地址储存在变量p所代表的的那片空间上。 (现在p就是储存着堆区的地址)  
将常量区"hello"的首元素'h'的地址储存在变量p所代表的的那片空间上。（也就是说，p现在不储存堆区的地址，储存'h'的地址）

7）char \*p = malloc(sizeof(char)\*10);  
strcpy(p,"hello");

正确，在内存空间上，连续申请8个字节，然后使用变量p间接访问这片内存空间，然后在堆区中连续申请10个字节，然后把堆区的地址储存在变量p所代表的的那片空间上。 (现在p就是储存着堆区的地址)  
将常量区"hello"字符串拷贝到p指向的那片堆区中。

二、结构体。  
1、什么是结构体？  
多个相同类型的变量放在一个集合中，那么这个集合就是叫做数组。 int A\[5\] -> 5个int类型的数据。  
多个不同类型的变量放在一个集合中，那么这个集合就是叫做结构体。

结构体可以包含什么类型的数据？  
基本数据类型： char/short/int/long/float/double  
非基本数据类型：数组/指针/结构体

结构体理解成就是一种新的类型，这种新的类型由什么东西组成的呢，就由用户自定义。

不可以包含的内容：函数。 （可以写函数指针，但是就是不能写函数）

=============================================================================  
2、结构体既然属于用户自定义类型，那么这种新类型该如何定义？  
关键词：struct  
模型：  
struct 结构体名字\{ -> 结构体名字最好与功能相符合。  
/\* 结构体的组成变量 \*/  
....;  
....;  
....;  
\}; -> 后面定义完结构体之后，记得这个位置是有一个分号。

例子：  
struct A\{  
char a; -> char -> 基本数据类型  
int b; -> int -> 基本数据类型  
char \*p; -> char\* -> 非基本数据类型  
int B\[3\]; -> 数组 -> 非基本数据类型  
\};  
这个就是一种新类型，这种类型是由一个字符变量，一个整型变量，一个字符指针变量，一个整型数组组成。

总结： 只要你的代码中使用了结构体，就一定要说清楚这个结构体是由什么东西组成。

=============================================================================

3、结构体的出现是为了解决什么问题？  
如果有一个"东西"，需要描述这个东西类型非常多，那么就可以考虑使用结构体。  
例如：要描述老关这个人，需要姓名，年龄，电话号码，那么就可以考虑使用结构体。  
struct person\_state\{  
char name\[10\];  
int age;  
char tel\[12\];  
\}; -> 新的数据类型

=============================================================================

4、如何声明结构体变量？  
1）先声明好结构体长什么样子？  
struct person\_state\{  
char name\[10\];  
int age;  
char tel\[12\];  
\};

系统就会知道"struct person\_state"（新类型）是由"char name\[10\];" + "int age;" + "char tel\[12\];"这三个东西组成。  
我们可以理解成"struct person\_state"就是新类型的名字。

int -> 基本数据类型  
char -> 基本数据类型  
char \* -> 非基本数据类型  
struct person\_state -> 非基本数据类型

盐+糖+xx+xx=混酱（新类型） -> struct person\_state -> 后天定义  
盐（基本数据类型） -> int -> 天生就在系统中

2）定义结构体变量。  
公式： 数据类型 变量名  
int a  
struct person\_state ggy; -> 这个ggy变量就包含了三个成员。

数据类型： struct person\_state （新类型，自己定义的新类型）  
变量名： ggy

=============================================================================

5、如何声明结构体指针？  
0）先声明好结构体长什么样子？  
struct person\_state\{  
char name\[10\];  
int age;  
char tel\[12\];  
\};

1）先声明好指针指向的目标。  
struct person\_state ggy;

2）定义一个结构体指针并赋值。  
struct person\_state \*p = &ggy;

数据类型： struct person\_state \*  
变量名：p

=============================================================================

6、结构体变量如何访问成员？  
1）先声明好结构体长什么样子？  
struct person\_state\{  
char name\[10\];  
int age;  
char tel\[12\];  
\};

2）先声明好指针指向的目标。  
struct person\_state ggy;

3）结构体变量使用"."来对成员进行访问。  
strcpy(ggy.name,"ggy");  
ggy.age = 10;  
strcpy(ggy.tel,"10086");

=============================================================================

7、结构体指针如何访问成员？  
1）先声明好结构体长什么样子？  
struct person\_state\{  
char name\[10\];  
int age;  
char tel\[12\];  
\};

2）先声明好指针指向的目标。  
struct person\_state ggy;

3）定义一个结构体指针  
struct person\_state \*p = &ggy;

4）结构体指针使用"->"来对成员进行访问。  
strcpy(p->name,"ggy");  
p->age = 10;  
strcpy(p->tel,"10086");

=============================================================================

8、结构体赋值。  
1）使用变量与指针对单个成员进行赋值。  
struct person\_state\{  
char name\[10\];  
int age;  
char tel\[12\];  
\};

struct person\_state ggy;  
struct person\_state \*p = &ggy;

ggy.age = 18;  
p->age = 18;

2）使用初始化列表。  
struct person\_state ggy = \{"ggy",18,"10086"\};  
struct person\_state ggy = \{"ggy"\}; -> 剩余没有赋值的成员如果是普通变量就是0，如果是指针就是NULL。

3）整个结构体赋值。  
struct person\_state ggy = \{"ggy",18,"10086"\};  
struct person\_state abc;  
abc = ggy;

练习4： 研究结构体数组该如何写？

定义数组的步骤：  
例如1： 定义具有5个int类型数据的数组。

第一步：确定一个数组名 A  
第二步：确定数组中元素的个数，使用\[\]括住他，跟在数组名后面 A\[5\]  
第三步：确定数组中每一个成员是什么 int a  
第四步：将第3步的结果的变量名去掉 int  
第五步：将第4步的结果写在第2步结果的前面就可以 int A\[5\] -> 最终结果。

struct person\_state\{  
char name\[10\];  
int age;  
char tel\[12\];  
\}; -> 先说明清楚struct person\_state是怎么组成。

例如： 定义具有3个struct person\_state类型数据的数组。

第一步： 确定一个数组名 B  
第二步： 确定数组中元素的个数，使用\[\]括住他，跟在数组名后面 B\[3\]  
第三步： 确定数组中每一个成员是什么 struct person\_state A  
第四步： 将第3步的结果的变量名去掉 struct person\_state  
第五步： 将第4步的结果写在第2步结果的前面就可以 struct person\_state B\[3\]

练习5： 做一个通讯录，里面可以存放三个同学的信息，每一个同学的信息都包含：姓名，年龄，电话号码  
要求： 程序运行之后，先依次对三个同学的姓名，年龄，电话号码进行注册 -> scanf()  
全部同学的信息注册完之后，就输出全部的同学的信息。

\#include <stdio.h>

//1. 先声明好这种新类型"struct person\_state"长什么样子。  
struct person\_state\{  
char name\[10\]; //姓名  
int age; //年龄  
char tel\[12\]; //电话号码  
\};

int main(int argc,char \*argv\[\])  
\{  
//2. 定义一个结构体数组  
struct person\_state A\[3\];  
  
//3. 依次对结构体成员赋值  
int i;  
for(i=0;i<3;i++)  
\{  
printf("pls input no.%d name:",i+1);  
scanf("%s",A\[i\].name);  
  
printf("pls input no.%d age:",i+1);  
scanf("%d",&(A\[i\].age));  
  
printf("pls input no.%d tel:",i+1);  
scanf("%s",A\[i\].tel);  
\}  
  
//4. 输出全部人的信息  
for(i=0;i<3;i++)  
\{  
printf("%s %d %s\\n",A\[i\].name,A\[i\].age,A\[i\].tel);  
\}  
  
return 0;  
\}