C语言学习之路（高级篇）—— 变量和内存分布（下）

Bertha 。 2024-03-31 16:36 74阅读 0赞

说明：该篇博客是博主一字一码编写的，实属不易，请尊重原创，谢谢大家！

## 程序的内存分区模型 ##

### 1) 内存分区 ###

#### 1.1 运行之前 ####

我们要想执行我们编写的c程序，那么第一步需要对这个程序进行编译。

1.  预处理：宏定义展开、头文件展开、条件编译，这里并不会检查语法
2.  编译：检查语法，将预处理后文件编译生成汇编文件
3.  汇编：将汇编文件生成目标文件(二进制文件)
4.  链接：将目标文件链接为可执行程序

当我们编译完成生成可执行文件之后，我们通过在`linux`下`size`命令可以查看一个可执行二进制文件基本情况：

![在这里插入图片描述][e57ea73cdfe543b4b9195ca1d7734350.png]

通过上图可以得知，在没有运行程序前，也就是说程序没有加载到内存前，可执行程序内部已经分好3段信息，分别为代码区（text）、数据区（data）和未初始化数据区（bss）3 个部分（有些人直接把data和bss合起来叫做静态区或全局区）。

*  **代码区**  
    存放 `CPU` 执行的机器指令。通常代码区是可共享的（即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指t令。另外，代码区还规划了局部变量的相关信息。
 *  **全局初始化数据区/静态数据区（data段）**  
    该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）。
 *  **未初始化数据区（又叫 bss 区）**  
    存入的是全局未初始化变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为 `0` 或者空（`NULL`）。

> **总体来讲说，程序源代码被编译之后主要分成两种段：程序指令(代码区)和程序数据（数据区）。代码段属于程序指令，而数据域段和.bss段属于程序数据。**

那为什么把程序的指令和程序数据分开呢？

*  程序被`load`到内存中之后，可以将数据和代码分别映射到两个内存区域。由于数据区域对进程来说是可读可写的，而指令区域对程序来讲说是只读的，所以分区之后呢，可以将程序指令区域和数据区域分别设置成可读可写或只读。这样可以防止程序的指令有意或者无意被修改；
 *  当系统中运行着多个同样的程序的时候，这些程序执行的指令都是一样的，所以只需要内存中保存一份程序的指令就可以了，只是每一个程序运行中数据不一样而已，这样可以节省大量的内存。比如说之前的`Windows Internet Explorer 7.0`运行起来之后， 它需要占用`112844KB`的内存，它的私有部分数据有大概`15944KB`，也就是说有`96900KB`空间是共享的，如果程序中运行了几百个这样的进程，可以想象共享的方法可以节省大量的内存。

#### 1.2 运行之后 ####

程序在加载到内存前，代码区和全局区(data和bss)的大小就是固定的，程序运行期间不能改变。然后，运行可执行程序，操作系统把物理硬盘程序load(加载)到内存，除了根据可执行程序的信息分出代码区（text）、数据区（data）和未初始化数据区（bss）之外，还额外增加了栈区、堆区。

*  **代码区（text segment）**  
    加载的是可执行文件代码段，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的。
 *  **未初始化数据区（BSS）**  
    加载的是可执行文件`BSS`段，位置可以分开亦可以紧靠数据段，存储于数据段的数据（全局未初始化，静态未初始化数据）的生存周期为整个程序运行过程。
 *  **全局初始化数据区/静态数据区（`data segment`）**  
    加载的是可执行文件数据段，存储于数据段（全局初始化，静态初始化数据，文字常量(只读)）的数据的生存周期为整个程序运行过程。
 *  **栈区（stack）**  
    栈是一种先进后出的内存结构，由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放，因此，局部变量的生存周期为申请到释放该段栈空间。
 *  **堆区（heap）**  
    堆是一个大容器，它的容量要远远大于栈，但没有栈那样先进后出的顺序。用于动态内存分配。堆在内存中位于`BSS`区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

<table> 
 <thead> 
  <tr> 
   <th align="center">类型</th> 
   <th align="center">作用域</th> 
   <th align="center">生命周期</th> 
   <th align="center">存储位置</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>auto</code>变量</td> 
   <td align="center">一对<code>{}</code>内</td> 
   <td align="center">当前函数</td> 
   <td align="center">栈区</td> 
  </tr> 
  <tr> 
   <td align="center"><code>static</code>局部变量</td> 
   <td align="center">一对<code>{}</code>内</td> 
   <td align="center">整个程序运行期</td> 
   <td align="center">初始化在<code>data</code>段，未初始化在<code>BSS</code>段</td> 
  </tr> 
  <tr> 
   <td align="center"><code>extern</code>变量</td> 
   <td align="center">整个程序</td> 
   <td align="center">整个程序运行期</td> 
   <td align="center">初始化在<code>data</code>段，未初始化在<code>BSS</code>段</td> 
  </tr> 
  <tr> 
   <td align="center"><code>static</code>全局变量</td> 
   <td align="center">当前文件</td> 
   <td align="center">整个程序运行期</td> 
   <td align="center">初始化在<code>data</code>段，未初始化在<code>BSS</code>段</td> 
  </tr> 
  <tr> 
   <td align="center"><code>extern</code>函数</td> 
   <td align="center">整个程序</td> 
   <td align="center">整个程序运行期</td> 
   <td align="center">代码区</td> 
  </tr> 
  <tr> 
   <td align="center"><code>static</code>函数</td> 
   <td align="center">当前文件</td> 
   <td align="center">整个程序运行期</td> 
   <td align="center">代码区</td> 
  </tr> 
  <tr> 
   <td align="center"><code>register</code>变量</td> 
   <td align="center">一对<code>{}</code>内</td> 
   <td align="center">当前函数</td> 
   <td align="center">运行时存储在<code>CPU</code>寄存器</td> 
  </tr> 
  <tr> 
   <td align="center">字符串常量</td> 
   <td align="center">当前文件</td> 
   <td align="center">整个程序运行期</td> 
   <td align="center"><code>data</code>段</td> 
  </tr> 
 </tbody> 
</table>

总结：

> 栈区  
> 1、先进后出（后进先出）  
> 2、编译器管理数据开辟、释放  
> 3、容量有限，不要将大量数据开辟到栈区  
> 堆区  
> 1、容量远远大于栈区  
> 2、程序员手动开辟数据（malloc），手动释放数据（free）

### 2) 分区模型 ###

#### 2.1 栈区 ####

由系统进行内存的管理。主要存放函数的参数以及局部变量。在函数完成执行，系统自行释放栈区内存，不需要用户管理。

**栈区注意事项：** 不要返回局部变量的地址，局部变量在函数体执行完毕过后会被释放，再次操作就是非法操作，结果未知！  
**示例1：**

#define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int* func03()
    {
        
    	int a = 10; // 栈上创建的变量，当函数结束后会被释放
    	return &a;
    }
    
    void test13()
    {
        
    	int* p = func03();
    	// 因为func03调用结束后，变量a早已被释放，再去操作这块内存就属于非法操作
    	printf("*p = %d\n", *p); // 第一次打印结果为10，是出于编译器的保护，编译器会认为你误操作
    	printf("*p = %d\n", *p); // 第二次打印结果就不是10了
    }
    
    int main()
    {
        
    	test13();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][4cc76643bf9c4d15a9b308625157e35e.png]

**示例2：**

char* getString()
    {
        
    	char str[] = "hello cdtaogang";
    	return str;
    
    }
    void test14()
    {
        
    	char* p = NULL;
    	p = getString();
    	printf("p = %s\n", p);
    
    }
    
    int main()
    {
        
    	test14();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][0c12ccf503324fcea65d18bf54641a07.png]

![在这里插入图片描述][6b7ed38d884e4461a310cff5f94785a0.png]

#### 2.2 堆区 ####

由编程人员手动申请，手动释放，若不手动释放，程序结束后由系统回收，生命周期是整个程序运行期间。使用`malloc`或者`new`进行堆的申请。

**堆区的使用：**

**示例：**

int* getSpace()
    {
        
    	int* p = malloc(sizeof(int) * 5);
    	for (int i = 0; i < 5; i++)
    	{
        
    		p[i] = 100 + i;
    	}
    	return p;
    }
    
    void test15()
    {
        
    	int* p = getSpace();
    	for (int i = 0; i < 5; i++)
    	{
        
    		printf("p[%d] = %d\n", i, p[i]);
    	}
    	// 释放堆区数据
    	free(p);
    	p = NULL; // 这一步是避免成为野指针
    }
    
    int main()
    {
        
    	test15();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][c6dd080e4364430181ed834cc6a94290.png]

**堆区注意事项：** 在主调函数中一个空指针分配内存，在被调函数中，利用同级的指针是分配（修饰）失败的。

**示例：**

void allocateSpace(char* pp)
    {
        
    	char* temp = malloc(100);
    	memset(temp, 0, 100);
    	strcpy(temp, "hello cdtaogang");
    	pp = temp;
    }
    
    void test16()
    {
        
    	char* p = NULL;
    	allocateSpace(p);
    	printf("p = %s\n", p);
    }
    
    int main()
    {
        
    	test16();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][9c5e4b3886744f51b5fca473ae8d3267.png]

![在这里插入图片描述][26fbb04691ad46b391ffd5d93af7aae2.png]

**解决方法：** 利用高级指针修饰低级指针

**示例：**

void allocateSpace2(char** pp)
    {
        
    	char* temp = malloc(100);
    	memset(temp, 0, 100);
    	strcpy(temp, "hello cdtaogang");
    	*pp = temp;
    }
    
    void test17()
    {
        
    	char* p = NULL;
    	allocateSpace2(&p);
    	printf("p = %s\n", p);
    }

![在这里插入图片描述][6479423d2179418cb83c2445d90809d0.png]

![在这里插入图片描述][774ef1e89edb4a179fa7fd978bf34dcc.png]

#### 2.3 全局/静态区 ####

全局静态区内的变量在编译阶段已经分配好内存空间并初始化。这块内存在程序运行期间一直存在,它主要存储全局变量、静态变量和常量。

**注意：**  
（1）这里不区分初始化和未初始化的数据区，是因为静态存储区内的变量若不显示初始化，则编译器会自动以默认的方式进行初始化，即静态存储区内不存在未初始化的变量。  
（2）全局静态存储区内的常量分为常变量和字符串常量，一经初始化，不可修改。静态存储内的常变量是全局变量，与局部常变量不同，区别在于局部常变量存放于栈，实际可间接通过指针或者引用进行修改，而全局常变量存放于静态常量区则不可以间接修改。  
（3）字符串常量存储在全局/静态存储区的常量区。

1.  **静态变量**

**示例代码：**只初始化一次，在编译阶段就分配内存，属于内部链接属性，只能在当前文件中使用

#define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    // 静态变量
    static int a = 10; // 特点：只初始化一次，在编译阶段就分配内存，属于内部链接属性，只能在当前文件中使用
    
    void test18() // 局部静态变量,作用域只能在当前test18中
    {
        	
    	// a 和 b的生命周期是一样的
    	static int b = 20;
    }
    
    int main()
    {
        	
    	g_a = 2000; // error g_a默认为内部链接属性，在文件外是无法访问g_a的
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][c490396d291f4ef9a4b9e499fd04f401.png]

1.  **全局变量**

**示例代码：**在`C`语言下 全局变量前都隐藏加了关键字 `extern`，属于外部链接属性

#define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    // 静态变量
    static int a = 10; // 特点：只初始化一次，在编译阶段就分配内存，属于内部链接属性，只能在当前文件中使用
    
    void test18() // 局部静态变量,作用域只能在当前test18中
    {
        	
    	// a 和 b的生命周期是一样的
    	static int b = 20;
    }
    
    // 全局变量
    extern int c = 100; //在C语言下 全局变量前都隐藏加了关键字  extern，属于外部链接属性
    
    void test19()
    {
        
    	extern int g_b;//告诉编译器 g_b是外部链接属性变量，下面在使用这个变量时候不要报错
    	printf("g_b = %d\n", g_b);
    
    }
    int main()
    {
        	
    	//g_a = 2000; // error g_a默认为内部链接属性，在文件外是无法访问g_a的
    	test19();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][5a1dbc12af54461aa476ff2d0e24e4ce.png]

1.  **常量**

**示例代码：**`const`修饰的全局变量,即使语法通过，但是运行时候受到常量区的保护，运行失败

#define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    //1、const修饰的全局变量,即使语法通过，但是运行时候受到常量区的保护，运行失败
    const int a1 = 10; //放在常量区
    
    void test20()
    {
        
    	//a1 = 100; //直接修改 失败
    
    	// 间接修改，语法通过，但运行失败
    	int* p = &a1;
    	*p = 100;
    
    	printf("%d\n", a1);
    }
    
    int main()
    {
        
    	test20();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][ec81d7d4e12848808a354ed942598937.png]

**示例代码：**`const`修饰的局部变量，数据存放在栈区，`C`语言下称为伪常量，不受常量区保护

//2、const修饰的局部变量
    void test21()
    {
        
    	const int b = 10; // 数据存放在栈区，C语言下称为伪常量
    	// b = 100; // 直接修改失败的
    	// 间接修改成功，分配到栈上，没有常量区保护
    	int* p = &b;
    	*p = 100;
    	printf("b = %d\n", b);
    	//int a[b]; // 伪常量是不可以初始化数组的
    }
    
    int main()
    {
        
    	test21();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][c213017fa2784ba39c139ccbe517013c.png]

**示例代码：**字符串常量是可以共享的，不允许修改字符串常量

//3、字符串常量
    void test22()
    {
        
    	char* p1 = "hello cdtaogang";
    	char* p2 = "hello cdtaogang";
    	char* p3 = "hello cdtaogang";
    	// 字符串常量是可以共享的
    	printf("%d\n", p1);
    	printf("%d\n", p2);
    	printf("%d\n", p3);
    	printf("%d\n", &"hello cdtaogang");
    
    	p1[0] = 'b'; // 不允许修改字符串常量
    	printf("%c\n", p1[0]);
    }
    
    int main()
    {
        
    	test22();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][289245a0ad154af6b60e108e1b092b34.png]

**字符串常量是否可修改？字符串常量优化：**

> ANSI C中规定：修改字符串常量，结果是未定义的。 ANSI C并没有规定编译器的实现者对字符串的处理，例如：  
> 1.有些编译器可修改字符串常量，有些编译器则不可修改字符串常量。  
> 2.有些编译器把多个相同的字符串常量看成一个（这种优化可能出现在字符串常量中，节省空间），有些则不进行此优化。如果进行优化，则可能导致修改一个字符串常量导致另外的字符串常量也发生变化，结果不可知。  
> 所以尽量不要去修改字符串常量！

**字符串常量地址是否相同？**

> TC2.0，同文件字符串常量地址不同。  
> VS2013及以上，字符串常量地址同文件和不同文件都相同。  
> Dev C++、QT同文件相同，不同文件不同。

#### 2.4 总结 ####

在理解`C/C++`内存分区时，常会碰到如下术语：数据区，堆，栈，静态区，常量区，全局区，字符串常量区，文字常量区，代码区等等，初学者被搞得云里雾里。在这里，尝试捋清楚以上分区的关系。

**数据区包括：** 堆，栈，全局/静态存储区。

**全局/静态存储区包括：** 常量区，全局区、静态区。

**常量区包括：** 字符串常量区、常变量区。

**代码区：** 存放程序编译后的二进制代码，不可寻址区。

**可以说，C/C++内存分区其实只有两个，即代码区和数据区**

### 3) 函数调用模型 ###

#### 3.1 宏函数 ####

#define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define MYADD(x, y) x+y
    // 运算保证完整性
    #define MYADD2(x, y) ((x)+(y))
    
    // 在预编译阶段做了宏替换
    // 宏函数注意：保证运算的完整性
    // 宏函数使用场景：将频繁短小的函数，封装为宏函数
    // 优点：以空间换时间（入栈和出栈的时间）
    void test23()
    {
        
    	int a = 10;
    	int b = 20;
    
    	printf("a + b = %d\n", MYADD(a, b)); // x+y == a+b == 10+20 = 30
    	printf("a + b = %d\n", MYADD(a, b) * 20); // x+y*20 == a+b*20 == 10+20*20 == 410
    	// 运算保证完整性
    	printf("a + b = %d\n", MYADD2(a, b)); // 30
    	printf("a + b = %d\n", MYADD2(a, b) * 20); // 600
    }
    
    int main()
    {
        
    	test23();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][0fd1523a1c5f41e0a2abceee3d2bb069.png]

#### 3.2 函数调用流程 ####

栈(`stack`)是现代计算机程序里最为重要的概念之一，几乎每一个程序都使用了栈，没有栈就没有函数，没有局部变量，也就没有我们如今能见到的所有计算机的语言。在解释为什么栈如此重要之前，我们先了解一下传统的栈的定义：

在经典的计算机科学中，栈被定义为一个特殊的容器，用户可以将数据压入栈中(入栈，`push`)，也可以将压入栈中的数据弹出(出栈，`pop`),但是栈容器必须遵循一条规则：先入栈的数据最后出栈(`First In Last Out，FILO`)

在经典的操作系统中，栈总是向下增长的。压栈的操作使得栈顶的地址减小，弹出操作使得栈顶地址增大。

栈在程序运行中具有极其重要的地位。最重要的，栈保存一个函数调用所需要维护的信息，这通常被称为堆栈帧(`Stack Frame`)或者活动记录(`Activate Record`).一个函数调用过程所需要的信息一般包括以下几个方面：

*  函数的返回地址；
 *  函数的参数；
 *  局部变量；
 *  保存的上下文：包括在函数调用前后需要保持不变的寄存器。

我们从下面的代码，分析以下函数的调用过程：

int func(int a,int b){
        
    	int t_a = a;
    	int t_b = b;
    	return t_a + t_b;
    }
    
    int main(){
        
    	int ret = 0;
    	ret = func(10, 20);
    	return EXIT_SUCCESS;
    }

**思考1：**`a、b`变量入栈，是从左往右还是从右往左？  
**思考2：**`a、b`变量是由`main`函数(主调函数)管理释放还是由`func`函数(被调函数)管理释放？

#### 3.3 调用惯例 ####

现在，我们大致了解了函数调用的过程，这期间有一个现象，那就是函数的调用者和被调用者对函数调用有着一致的理解，例如，它们双方都一致的认为函数的参数是按照某个固定的方式压入栈中。如果不这样的话，函数将无法正确运行。

如果函数调用方在传递参数的时候先压入`a`参数，再压入`b`参数，而被调用函数则认为先压入的是`b`，后压入的是`a`，那么被调用函数在使用`a,b`值时候，就会颠倒。

因此，**函数的调用方和被调用方对于函数是如何调用的必须有一个明确的约定，只有双方都遵循同样的约定，函数才能够被正确的调用，这样的约定被称为 “调用惯例(Calling Convention) ”** ，一个调用惯例一般包含以下几个方面：

**函数参数的传递顺序和方式**  
函数的传递有很多种方式，最常见的是通过栈传递。函数的调用方将参数压入栈中，函数自己再从栈中将参数取出。对于有多个参数的函数，调用惯例要规定函数调用方将参数压栈的顺序：从左向右，还是从右向左。有些调用惯例还允许使用寄存器传递参数，以提高性能。

**栈的维护方式**  
在函数将参数压入栈中之后，函数体会被调用，此后需要将被压入栈中的参数全部弹出，以使得栈在函数调用前后保持一致。这个弹出的工作可以由函数的调用方来完成，也可以由函数本身来完成。

为了在链接的时候对调用惯例进行区分，调用惯例要对函数本身的名字进行修饰。不同的调用惯例有不同的名字修饰策略。

事实上，在`c`语言里，存在着多个调用惯例，而默认的是`cdecl`.任何一个没有显示指定调用惯例的函数都是默认是`cdecl`惯例。比如我们上面对于`func`函数的声明，它的完整写法应该是：

int _cdecl func(int a,int b);

**注意:** `_cdecl`不是标准的关键字，在不同的编译器里可能有不同的写法，例如`gcc`里就不存在`_cdecl`这样的关键字，而是使用`__attribute__((cdecl))`.

<table> 
 <thead> 
  <tr> 
   <th align="center">调用惯例</th> 
   <th align="center">出栈方</th> 
   <th align="center">参数传递</th> 
   <th align="center">名字修饰</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>cdecl</code></td> 
   <td align="center">函数调用方</td> 
   <td align="center">从右至左参数入栈</td> 
   <td align="center">下划线+函数名</td> 
  </tr> 
  <tr> 
   <td align="center"><code>stdcall</code></td> 
   <td align="center">函数本身</td> 
   <td align="center">从右至左参数入栈</td> 
   <td align="center">下划线+函数名+@+参数字节数</td> 
  </tr> 
  <tr> 
   <td align="center"><code>fastcall</code></td> 
   <td align="center">函数本身</td> 
   <td align="center">前两个参数由寄存器传递，其余参数通过堆栈传递。</td> 
   <td align="center">@+函数名+@+参数的字节数</td> 
  </tr> 
  <tr> 
   <td align="center"><code>pascal</code></td> 
   <td align="center">函数本身</td> 
   <td align="center">从左至右参数入栈</td> 
   <td align="center">较为复杂，参见相关文档</td> 
  </tr> 
 </tbody> 
</table>

#### 3.4 函数变量传递分析 ####

![在这里插入图片描述][d85251ecdc2d45b496a7a3645cf98ff0.png]

![在这里插入图片描述][7bb58c417f894f928f9a72189e62680f.png]

![在这里插入图片描述][73d313aae4874731b30564455c66785e.png]

![在这里插入图片描述][e59d4f82e1084dfeb50115b016321b9b.png]

![在这里插入图片描述][2a43dc51ec32429cb94fe61850e3a7f4.png]

**简单示例：**

#define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    void B()
    {
        
    
    }
    
    void A()
    {
        
    	int b; // 在函数A、B中可以使用，但在main函数中使用不了
    	B();
    }
    
    int main()
    {
        
    	int a;  // 在main函数和A、B函数中都可以使用(传参)
    	A();
    	system("pause");
    	return EXIT_SUCCESS;
    }

### 4) 栈的生长方向和内存存放方向 ###

#### 4.1 栈的生长方向 ####

![在这里插入图片描述][8cceddca0fba49eaa9feadc12074dbdd.png]

#define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    // 栈的生长方向
    void test24()
    {
        
    	int a = 10;  // 栈底-高地址
    	int b = 20;
    	int c = 30;
    	int d = 40;  // 栈顶-低地址
    
    	printf("%d\n", &a);
    	printf("%d\n", &b);
    	printf("%d\n", &c);
    	printf("%d\n", &d);
    }
    
    int main()
    {
        
    	test24();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][263f9bd7c7474e24b8a79980a5d9844c.png]

#### 4.2 内存存放方向 ####

![在这里插入图片描述][bfa4e56386b64e6195000e8f60045264.png]

#define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    // 内存存放方向
    void test25()
    {
        
    	int a = 0x11223344;
    	char* p = &a;
    	// 小端结果，大端相反
    	printf("%x\n", *p); // 44 - 低位字节 - 低地址
    	printf("%x\n", *(p+1)); // 33 - 相对44 高位字节 - 高地址
    	printf("%x\n", *(p + 2)); // 22
    	printf("%x\n", *(p + 3)); // 11
    }
    
    int main()
    {
        
    	test25();
    	system("pause");
    	return EXIT_SUCCESS;
    }

![在这里插入图片描述][d114f3873c4844a281c535226b22044b.png]

[e57ea73cdfe543b4b9195ca1d7734350.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/cacdaa2732974b73be07460f61fc0642.png
[4cc76643bf9c4d15a9b308625157e35e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/7e9e8c2b34c44fc79eeb8c8b381c228e.png
[0c12ccf503324fcea65d18bf54641a07.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ef0c2f376da941ba900bcdcf29f5e1a7.png
[6b7ed38d884e4461a310cff5f94785a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d899aec6ca814748ac0d6669d482404b.png
[c6dd080e4364430181ed834cc6a94290.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/3c074fe85ed744c682dd7dfabad77316.png
[9c5e4b3886744f51b5fca473ae8d3267.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/82405cec6deb47a18b41a47e804649fe.png
[26fbb04691ad46b391ffd5d93af7aae2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/bef00d50f8bc48869761889e3d2e5f3c.png
[6479423d2179418cb83c2445d90809d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/af20ad4221584d07a26b58118618d617.png
[774ef1e89edb4a179fa7fd978bf34dcc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/7fd6dc44544e4d928e6e370c65be12d4.png
[c490396d291f4ef9a4b9e499fd04f401.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/0c1992356f1c4028ad4c142833f261cc.png
[5a1dbc12af54461aa476ff2d0e24e4ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/0f3d9aeaf6934b36a53b9fa440050490.png
[ec81d7d4e12848808a354ed942598937.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5959c4ddb4e447c5af03cfe9f60342c0.png
[c213017fa2784ba39c139ccbe517013c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/2384dc341f3c4cb7aeaf03c5f280aff7.png
[289245a0ad154af6b60e108e1b092b34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c15f1bbc173c4e29a601baec163b858e.png
[0fd1523a1c5f41e0a2abceee3d2bb069.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c43b9129ab054d36bdbf476f28c86737.png
[d85251ecdc2d45b496a7a3645cf98ff0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f159b23fa02746c099c32552a04dee80.png
[7bb58c417f894f928f9a72189e62680f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4538b72b013441319c7e28b4b34876f5.png
[73d313aae4874731b30564455c66785e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/696af373f6c045898238f0d772a8b9f6.png
[e59d4f82e1084dfeb50115b016321b9b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/b92d4f9a6fed4a1d8a93b70aa8c854b5.png
[2a43dc51ec32429cb94fe61850e3a7f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/98308e7357b540cb99cdb03df1f990c7.png
[8cceddca0fba49eaa9feadc12074dbdd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/59452c5347ff4f2b869d58c5b16d49b2.png
[263f9bd7c7474e24b8a79980a5d9844c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c36c45da8eb948478c464c000cbb4f85.png
[bfa4e56386b64e6195000e8f60045264.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/66e56a6d36744643b5b3ceb50c00a47e.png
[d114f3873c4844a281c535226b22044b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/55c449e6f173403f8a6cf67d8c2a6d6a.png