02、内存分区

文章目录

• 02、内存分区
• • 2.1、数据类型
  • • 2.1.1、数据类型概念
    • 2.1.2、数据类型别名(typedef 的使用)
    • 2.1.3、void 数据类型（void 的使用）
    • 2.1.4、sizeof 的使用
    • 2.1.5、数据类型总结
  • 2.2、变量
  • • 2.2.1、变量的概念
    • 2.2.2、变量名的本质
  • 2.3、程序的内存分区模型
  • • 2.3.1、内存分区
    • • 2.3.1.1、运行之前
      • 2.3.1.2、运行之后
    • 2.3.2、分区模型
    • • 2.3.2.1、栈区
      • 2.3.2.2、堆区
      • 2.3.2.3、全局/静态区
    • 2.3.3、函数调用模型
    • • 2.3.3.0、宏函数
      • 2.3.3.1、函数调用流程
      • 2.3.3.2、调用惯例
      • 2.3.3.3、函数变量传递分析
    • 2.3.4、栈的生长方向和内存存放方向

2.1、数据类型

2.1.1、数据类型概念

  什么是数据类型？为什么需要数据类型？
  数据类型是由编译器制定出的，是为了更好进行内存的管理，让编译器能确定分配多少内存。
  我们现实生活中，狗是狗，鸟事鸟等等，每一种事物都有自己的类型，那么程序中使用数据类型也是来源于生活。
  当我们给狗分配内存的时候，也就相当于给狗建造狗窝，给鸟分配内存的时候，也就是给鸟建造一个鸟窝，我们可以给他们各自建造一个别墅，但是会造成内存的浪费，不能很好的利用内存空间。
  我们在想，如果给鸟分内存，只需要鸟窝大小的空间就够了，如果给狗分配内存，那么也只需要狗窝带下的内存，而不是给鸟和狗都分配一座别墅，造成内存的浪费。
  当我们定义一个变量，a = 10，编译器如何分配内存？计算只是一个机器，它怎么知道用多少内存可以放得下10？
  所以说，数据类型非常重要，它可以告诉编译器分配多少内存可以放得下我们的数据。
  狗窝里面是狗，鸟窝里面是鸟，如果没有数据类型，你怎么知道冰箱里放得是一头大象！

数据类型基本概念：

• 类型是对数据的抽象；
• 类型相同的数据具有相同的表示形式、存储格式以及相关操作；
• 程序中所有的数据都必定属于某种数据类型；
• 数据类型可以理解为创建变量的模具；固定大小内存的别名；

2.1.2、数据类型别名(typedef 的使用)

typedef 的主要用途是给数据类型器别名，还可以作以下用途：

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				        //std 标准 i-input 输入 o-output 输出
#include<string.h>				      //strcp strcmp strcat strstr
#include<stdlib.h>				      //std 标准 lib 库 malloc free

//1、使用typedef 简化结构体关键字 struct
//方式一：
//struct Person {
//	char name[64];
//	int age;
//};
//typedef struct Person myPerson;

//方式二：
typedef struct Person {
	char name[64];
	int age;
}myPerson;
//主要用途：给类型起别名
//语法：typedef 原名 别名

//2、区分数据类型
void test02() {
	//char * p1, p2;	//p1是char * 而 p2 是char

	typedef char * PCHAR;
	PCHAR p1, p2;	//p1,p2都是char *

	char *p3, *p4;	//p3,p4也都是char *
}

//3、提高代码的移植性
//比如在C99标准下才支持 long long 类型，如果在程序中使用了大量
//这种类型定义了变量，则在C89标准下就跑不起来
typedef int MYINT;	//typedef long long MYINT; 只需要替换 long long 就可以了
void test03() {
	//long long a = 10;
	//long long b = 20;

	MYINT a = 10;
	MYINT b = 20;

}

//程序入口
int main() {

	struct Person p1 = {"张三",10};

	myPerson p2 = {"李四",20};

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.1.3、void 数据类型（void 的使用）

  void 字面意思是”无类型“，void* 无类型指针，无类型指针可以指向任何类型的数据。
  void 定义变量时没有任何意义的，当你定义 void a，编译器会报错。
  void真正用在以下两个方面：
  1、对函数返回的限定；
  2、对函数参数的限定；

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

**//1、无类型时不可以创建变量，无法分配内存**
void test01() {
	//void a = 10;	//编译器直接报错，因为不知道给a分配多少内存空间
}

**//2、可以限定函数返回值**
void func() {
	//return 10;	//C语言不严谨，这边返回10，编译还是可以通过的，只是会报一个警告，函数的返回值是 void 类型
}

void test02() {
	//func();		//这边的函数调用是没问题的
	//printf("%d\r\n", func());		//这边的打印就有问题了，func()函数的返回类型是void，无法进行 %d 的打印
}

**//3、限定函数的参数列表**
//int func2() {
//	return 10;
//}
//
//void test03() {
//	printf("%d\r\n",func2(10));	//C语言不严谨，没有对函数输入参数进行检测，这种函数调用不会报错或者报警告
//}

//上下对比：

int func2(void) {	//函数形参明确指定了 void 类型
	return 10;
}

void test03() {
	//printf("%d\r\n",func2(10));	//C语言不严谨，没有对函数输入参数进行检测，这种函数调用不报错，只会产生一个警告，函数的形参类型是 void 类型
}

**//4、void * 万能指针，可以不需要强制类型转换，给其它指针赋值**
void test04() {
	void * p = NULL;
	
	int * pInt = NULL;
	char * pChar = NULL;

	//pChar = pInt;			//如果直接这样赋值会报警告C4133：从“int *”到“char *”的类型不兼容
	//pChar = (char *)pInt;	//进行强制类型转换就不会报警告了
	
	//上下对比：

	pChar = p;		//但是void *类型的指针就不需要进行强转，也不会报警告，这就是万能指针，可以不需要强制类型转换就可以给等号左边赋值

	printf("size of void *   = %d\r\n",sizeof(p));	//结果是 4，只要是指针不管是什么类型的指针，不管是几级的指针，它的结果都是 4
}

//程序入口
int main() {

	//test02();
	//test03();
	test04();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.1.4、sizeof 的使用

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

**//1、sizeof本质，是不是一个函数？？ 不是函数，它只是一个操作符，类似于 + - * / 运算符
//当统计类型占的内存空间时，必须要加 小括号
//当统计变量占的内存空间时，可以不加 小括号**
void test01() {

	//对于数据类型，sizeof 必须用 () 去使用，但是对于变量，可以不加 ()
	printf("size of int = %d\r\n",sizeof(int));		//size of int = 4

	double d = 3.14;
	//printf("size of d = %d\n",sizeof(d));			//size of d = 8
	//上面可以把()去掉，等价于下面
	printf("size of d = %d\n",sizeof d );			//size of d = 8
}

**//2、sizeof 的返回值类型是什么？ unsigned int 无符号整型**
void test02() {
	//unsigned int a = 10;
	//if (a - 20 > 0) {	//结果是大于 0，当unsigned int 和 int 类型数据做运算，编译器会将数据类型都转位 unsigned int
	//	printf("大于 0\r\n");
	//}
	//else {
	//	printf("小于 0\r\n");
	//}

	//上下对比：

	if (sizeof(int) - 5 >0) {	//结果是大于 0，说明 sizeof 的返回值类型是 unsigned int
		printf("大于 0\r\n");
	}
	else {
		printf("小于 0\r\n");
	}
}

**//3、sizeof 可以统计数组长度**
**//当数组名作为函数参数的时候，会退化为指针，指向数组中第一个元素**
void calculateArray(int arr[]) {
	printf("arr的数组长度：%d\n", sizeof(arr));	//结果 arr的数组长度：4
}

void test03() {
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
	//printf("arr的数组长度：%d\n", sizeof(arr));	//结果 arr的数组长度：32

	calculateArray(arr);	//参数arr指向数组第一个元素 1，1是int类型，长度为 4
}

//程序入口
int main() {

	//test01();
	//test02();
	test03();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.1.5、数据类型总结

• 数据类型本质是固定内存大小的别名，是个模具，C语言规定：通过数据类型定义变量；
• 数据类型大小计算（sizeof）；
• 可以给已存在的数据类型起别名typedef；
• l 数据类型的封装（void 万能类型）；

2.2、变量

2.2.1、变量的概念

  既能读又能写的内存对象，称为变量；
  若一旦初始化后不能修改的对象则称为常量。

变量定义形式：类型 标识符，标识符，…，标识符

2.2.2、变量名的本质

• 变量名的本质：一段连续内存空间的别名；
• 程序通过变量来申请和命名内存空间 int a = 0;
• 通过变量名访问内存空间；
• 不是向变量名读写数据，而是向变量多代表的内存空间中读写数据；

变量的修改方式

• 直接修改
• 间接修改
  • 通过指针对内存进行修改
  • 对自定义数据类型进行修改

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

void test01() {
	int a = 10;
	//直接修改
	a = 20;
	printf("a = %d\r\n", a);

	//间接修改
	int *p = &a;
	*p = 100;
	printf("a = %d\r\n", a);

}

//对于自定义数据类型
struct Person
{
	char a;	//0~3	内存对齐
	int b;	//4~7
	char c; //8~11
	int d;	//12~15
};

void test02() {
	struct Person p1 = {'a', 10, 'b', 20};

	//直接修改 d属性
	p1.d = 1000;

	//间接修改 d属性
	struct Person *p = &p1;
	//p->d = 2000;
	
	//printf("%d\r\n",p);			//8322288		
	//printf("%d\r\n", p+1);		//8322304，相差16

	char * pPerson = p;			//使用地址偏移进行修改
	//pPerson是一个char类型的指针，要获得d变量的地址，需要偏移12
	//由于d变量指向的数据是int类型，所以需要将地址转成(int*)，也就是取4个字节地址上的值
	//最后使用*进行解引用，获取d变量的值
	printf("d = %d\r\n", *(int *)(pPerson + 12));
	
	//从右→左，第一个(int*)是将(char*)类型的指针强转成(int*)类型的指针，然后偏移3，就是d的地址；
	//还有一个(int*)是指d的数据类型是int，所以要从d变量的首地址取int类型也就是4个字节地址上的值，就还要(int*)
	//最后使用*进行解引用，获取d变量中的值。
	printf("d = %d\r\n", *(int*)((int*)pPerson + 3));

}

//程序入口
int main() {

	//test01();
	test02();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.3、程序的内存分区模型

2.3.1、内存分区

2.3.1.1、运行之前

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

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

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

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

• 代码区

存放 CPU 执行的机器指令。通常代码区是可**共享**的（即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外的修改了它的指令。另外，代码区还规划了局部变量的相关信息。

• 全局初始化数据区/静态数据区（data段）

该区包含了在程序中明确被初始化的全局变量，已经初始化的静态变量（包括全局静态变量）和常量数据（如字符串常量）。

• 未初始化数据区（又叫 bss 区）

存入的是全局未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或者空（NULL）。

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

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

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

2.3.1.2、运行之后

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

• 代码区（text segment）

加载的是可执行文件代码段，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的。

• 未初始化数据区（BSS）

加载的是可执行文件 BSS 段，位置可以分开亦可以紧靠数据段，存储于数据段的数据（全局未初始化，静态未初始化数据）的生存周期未整个程序运行过程。

• 全局初始化数据区/静态数据区（data segment）

加载的是可执行文件数据段，存储于数据段（全局初始化，静态初始化数据，文字常量（只读））的数据的生存收起未整个程序运行过程。

• 栈区（stack）

栈是一种一斤后出的内存结构，由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放，因此，局部变量的生存周期为申请到释放该段栈空间。

• 堆区（heap）

堆是一个大容器，它的容量要远远大于栈，但没有栈那样现金后出的顺序。用于动态内存分配。

堆在内存中位于 BSS 区和栈区之间。一般由程序员分配（malloc）和释放（free），若程序员不释放，程序结束时由操作系统回收。

注意：建立正确程序运行内存布局图是学好C的关键！！

2.3.2、分区模型

2.3.2.1、栈区

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

char* func(){
	char p[] = "hello world!"; //在栈区存储 乱码
	printf("%s\n", p);
	return p;
}

void test(){
	char* p = NULL;
	p = func();  
	printf("%s\n",p); 
}

栈区的使用及注意事项：

1、不要返回局部变量的地址，因为局部变量在函数执行之后就释放了，我们没有权限去操作释放后的内存了。

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

//栈的注意事项，不要返回局部变量的地址
int * func() {
	int a = 10;
	return &a;
}

void test01() {
	int * p = func();

	//结果已经不重要了，因为a的内存已经被释放了，我们没有权限区操作这块内存了
	printf("a = %d\r\n", *p);	//这个打印的值可能还是 a=10, 但是这个只是编译给做的一次保留，怕进行误操作
	printf("a = %d\r\n", *p);	//这边打印的就是一个随机值了，因为在调用玩func()函数后，变量a已经被释放了
}

char * getString() {
	char str[] = "hello world";
	return str;
}

void test02() {
	char * p = NULL;
	p = getString();
	printf("%s\r\n",p);			//显示乱码，不是显示“hello world”
}

//程序入口
int main() {

	//test01();
	test02();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.3.2.2、堆区

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

char* func(){
	char* str = malloc(100);
	strcpy(str, "hello world!");
	printf("%s\n",str);
	return str;
}

void test01(){
	char* p = NULL;
	p = func();
	printf("%s\n",p);
}

void allocateSpace(char* p){
	p = malloc(100);
	strcpy(p, "hello world!");
	printf("%s\n", p);
}

void test02(){
	
	char* p = NULL;
	allocateSpace(p);

	printf("%s\n", p);
}

堆分配内存API：

#include <stdlib.h>
void *calloc(size_t nmemb, size_t size);
功能：
    在内存动态存储区中分配 nmemb 块长度为size字节的连续区域。calloc自动将分配的内存置0。
参数：
    nmemb:所需内存单元数量
    size:每个内存单元的大小（单位：字节）
返回值：
    成功：分配空间的起始地址
    失败：NULL
        
void * realloc(void *ptr,size_t size);
功能：
    重新分配用malloc或者calloc函数在堆中分配内存空间的大小。
    realloc不会自动清理增加的内存，需要手动清理，如果指定的地址后面没有空间，那么realloc会重新分配新的连续内存，把旧内存的值拷贝到新内存，同时释放就内存。
参数：
    ptr:为之前用malloc或者calloc分配的内存地址，如果此参数等于NULL，那么和realloc与malloc功能一致。
    size:为重新分配内存的大小，单位：字节
返回值：
	成功：新分配的堆内存地址
    失败：NULL
        
realloc的机制：如果比原来分配的内存要大，有两种情况：
        情况1：如果原来的空间后面有 足够大的空闲空间，那么直接在后面继续开辟内存，返回原有的首地址
        情况2：如果原来的空间后面，没有足够大的空闲空间，那么系统会直接分配一个新的空间，这个新空间就是需要的内存空间，将原有空间下的数据拷贝到新空间下，并且将原有空间释放，返回新空间的首地址

示例代码：

void test01(){
	
	int* p1 = calloc(10,sizeof(int));
	if (p1 == NULL){
		return;
	}
	for (int i = 0; i < 10; i ++){
		p1[i] = i + 1;
	}
	for (int i = 0; i < 10; i++){
		printf("%d ",p1[i]);
	}
	printf("\n");
	free(p1);
}

void test02(){
	int* p1 = calloc(10, sizeof(int));
	if (p1 == NULL){
		return;
	}
	for (int i = 0; i < 10; i++){
		p1[i] = i + 1;
	}

	int* p2 = realloc(p1, 15 * sizeof(int));
	if (p2 == NULL){
		return;
	}

	printf("%d\n", p1);
	printf("%d\n", p2);

	//打印
	for (int i = 0; i < 15; i++){
		printf("%d ", p2[i]);
	}
	printf("\n");

	//重新赋值
	for (int i = 0; i < 15; i++){
		p2[i] = i + 1;
	}
	//再次打印
	for (int i = 0; i < 15; i++){
		printf("%d ", p2[i]);
	}
	printf("\n");

	free(p2);
}

堆区的使用：

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

int * getSpace() {
	int *p = malloc(sizeof(int) * 5);	//开辟了一块 可以存放5个int类型数据的内存空间

	if (p == NULL) {
		return NULL;
	}

	for (int i = 0; i < 5; i++)
	{
		p[i] = i + 100;
	}
	return p;
}

void test01() {
	int * p = getSpace();			//由于堆空间是开发人员自己创建的一直每释放，所以地址中的值还在

	for (int i = 0; i < 5; i++)
	{
		printf("%d\r\n", p[i]);		//可以读取到值为 100、101、102、103、104
	}

	**//手动在堆区创建的数据，记得手动释放**
	free(p);	//假设指针 p 指向地址 0x01
	p = NULL;	//这句话的目的是防止 p 成为野指针，因为上面已经释放掉了 0x01地址上的内容，如果不将p指向NULL的话，p还是会指向0x01，而0x01地址上的内容已经是未知的了

}

//程序入口
int main() {

	test01();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

堆区注意事项：

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

**//注意事项
//如果主调函数中没有给指针分配内存，那么被调函数用同级指针是修饰不到主调函数中的指针的**
void allocateSpace(char * pp) {

	char * temp = malloc(100);	//开辟100个字节的内存空间，创建一个char类型的指针指向这块空间
	
	if (temp == NULL) {
		return;
	}
	
	memset(temp, 0, 100);		//给内存设值
	strcpy(temp, "hello world");
	pp = temp;

}

void test02() {
	char * p = NULL;
	allocateSpace(p);
	printf("%s\r\n", p);
  
  free(p);
	p = NULL;
}

//程序入口
int main() {

	test02();		//控制台打印（null）

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

**//注意事项
//如果在主调函数中没有给指针分配内存，那么被调函数中需要利用高级指针给只掉函数中指针分配内存**
void allocateSpace2(char ** pp) {
	char * temp = malloc(100);	//开辟100个字节的内存空间，创建一个char类型的指针指向这块空间
	memset(temp, 0, 100);		    //给内存设值
	strcpy(temp, "hello world");
	*pp = temp;
}

void test03() {
	char * p = NULL;
	allocateSpace2(&p);       //把指针 p 的地址给到 pp
	printf("%s\r\n", p);

	free(p);
	p = NULL;
}

//程序入口
int main() {
	//test01();
	//test02();		//控制台打印（null）
	test03();		//控制台打印 hello world

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.3.2.3、全局/静态区

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

 注意：

（1）这里不区分初始化和未初始化的数据区，是因为静态存储区内的变量若不显示初始化，则编译器会自动以默认的方式进行初始化，即静态存储区内不存在未初始化的变量。

（2）全局静态存储区内的常量分为常变量和字符串常量，一经初始化，不可修改。静态存储内的常变量是全局变量，与局部常变量不同，区别在于局部常变量存放于栈，实际可间接通过指针或者引用进行修改，而全局常变量存放于静态常量区则不可以间接修改。

（3）字符串常量存储在全局/静态存储区的常量区。

示例代码：

int v1 = 10;//全局/静态区
const int v2 = 20; //常量，一旦初始化，不可修改
static int v3 = 20; //全局/静态区
char *p1; //全局/静态区，编译器默认初始化为NULL

//那么全局static int 和 全局int变量有什么区别？

void test(){
	static int v4 = 20; //全局/静态区
}

加深理解：

char* func(){
	static char arr[] = "hello world!"; //在静态区存储 可读可写
	arr[2] = 'c';
	char* p = "hello world!"; //全局/静态区-字符串常量区 
	//p[2] = 'c'; //只读，不可修改 
	printf("%d\n",arr);
	printf("%d\n",p);
	printf("%s\n", arr);
	return arr;
}
void test(){
	char* p = func();
	printf("%s\n",p);
}

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

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

C99标准：

char *p = “abc”; defines p with type “pointer to char” and initializes it to point to an object with type “arrray of char” with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to modify the contents of the array, the behavior is usdefined.

数据区的使用及注意事项：

数据区放入的是静态变量，全局变量，常量

static 和 extern 区别：

static 静态变量：编译阶段分配内存，只能在当前文件内使用，只初始化一次

extern 全局变量，C语言下默认的全局变量前都隐藏加了该关键字

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

//1、静态变量
static int a = 10;	//特点，只初始化一次，在编译阶段就分配内存，属于内部链接属性，只能在当前文件中使用

void test01() {
	static int b = 20;	//局部静态变量，作用域只能在当前test01中

	//a 和 b的生命周期是一样的

}

//2、全局变量
extern int g_a = 100;	//在C语言下，全局变量前都隐藏加了关键字 extern，属于外部链接属性

void test02() {
	// g_b变量在 test.c 文件中定义了，此处没列出，知道就好
	extern int g_b;	//告诉编译器 g_b 是外部链接属性变量，下面在使用这个变量时候不要报错

	printf("g_b = %d\r\n", g_b);

}

//程序入口
int main() {

	a = 100;	//这个没问题，因为a是全局变量
	//b = 100;	//这个会报错 C2065	“b” : 未声明的标识符，因为b是局部变量

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

const修饰的全局变量和局部变量：

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

//1、const修饰的全局变量，即使语法通过，但是运行时候受到常量区的保护，运行失败**
const int a = 10;	//放在常量区

void test01() {

	//a = 100;	//直接修改 失败

	//间接修改失败,原因是放在常量区，受到保护
	//int *p = &a;
	//*P = 100;
	//printf("%d\r\n", a);	//此处看这虽然没有语法报错，但是运行时会崩掉
}

//2、const修饰的局部变量
void test02() {
	const int b = 10;	   //分配到栈上，有内存，并非放在常量区
	//b = 100;			     //直接修改失败的

	//间接修改成功，原因放在栈上
	//在 C 语言下，称为伪常量
	int *p = &b;
	*p = 100;
	printf("b = %d\n", b);

	//int a[b];	//伪常量是不可以初始化数组的

}

//程序入口
int main() {

	//test01();
	test02();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.3.3、函数调用模型

2.3.3.0、宏函数

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

//1、这种是宏定义，宏常量，在预编译的时候进行宏替换
//在代码中用到MAX的地方，在预编译阶段都替换成1024
#define	MAX	1024

//2、宏函数
//也是在预处理阶段进行宏替换
//注意事项：
//宏函数 要保证运算的完整性才可以，就是如下MYADD_1的宏函数会导致运算错误
//#define MYADD_1(x,y)	x + y
#define MYADD_2(x,y)	((x)+(y))

//3、为什么要使用宏函数？
//宏函数 在一定的程度上 会比普通的函数效率高，因为普通函数会有一个入栈和出栈时间上的开销
//我们通常将一些比较频繁、短小的函数封装为宏函数，直接跑源码
//优点：以空间 换 时间
int myAdd(int x, int y) {
	return x + y;
}

void test01() {
	int a = 10;
	int b = 20;

	//int ret = MYADD_1(a, b) * 20;	//10 + 20 * 20

	int ret = MYADD_2(a, b) * 20;	//((10) + (20)) * 20

	printf("ret=%d\n", ret);
}

//程序入口
int main() {

	test01();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.3.3.1、函数调用流程

  栈（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);		//在调用func函数时，会将下一条指令的地址（即调用完函数后继续要执行的地址）放入栈中
    return EXIT_SUCCESS;
}

程序执行过程中会将变量进行压栈操作

运算结束后，会释放内存，也就是出栈操作

针对以上运行分析，提出如下问题：

1、a 和 b 的入栈顺序是从左到右还是从右到左？

2、栈上的数据，是由 main（主调函数）释放还是由 func 函数（被调函数）管理释放？

2.3.3.2、调用惯例

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

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

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

  函数参数的传递顺序和方式

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

  栈的维护方式

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

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

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

int _cdecl func(int a, int b)；

  注意：_cdecl 不是标准的关键字，在不同的编译器里可能由不同的写法，例如 gcc 里就不存在 _cdecl 这样的关键字，而是使用 attribute((cdecl))。

2.3.3.3、函数变量传递分析

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

int g_a = 100;		//全局区 的数据在main、func1 和 func2 中都可以使用

//子函数2
void func2() {
	int a = 20;		//只能在 func2中 使用
}

//子函数1
void func1() {
	int a = 10;		//在main函数中不可以使用，在func1和func2中都可以使用

	func2();
}

//程序入口
int main() {

	int a = 10;		//在main 和 func1、func2中都可以使用

	func1();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

2.3.4、栈的生长方向和内存存放方向

#define _CRT_SECURE_NO_WARNINGS	//VS不建议使用传统的库函数，如果不使用这个宏，会出现一个错误，编号：C4996
#include<stdio.h>				//std 标准 i-input 输入 o-output 输出
#include<string.h>				//strcp strcmp strcat strstr
#include<stdlib.h>				//std 标准 lib 库 malloc free

//1、栈的生长方向
void test01() {

	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);

}

//2、内存的存储方向
void test02() {
	int a = 0xaabbccdd;

	unsigned char *p = &a;
	printf("%x\n", *p);			//低位字节数据 ---- 低地址
	printf("%x\n", *(p+1));		//高位字节数据 ---- 高地址
}

//程序入口
int main() {

//	test01();
    
    test02();

	system("pause");			//按任意键暂停，阻塞功能
	return EXIT_SUCCESS;		//返回 正常退出值 0
}

test01测试结果为：栈的生长方向为 栈底 - 高地址，栈顶 - 底地址

test02测试结果为：高位字节数据存放在高地址，低位字节数据存放在低地址，这种内存存储方式叫做小端对齐，反之，高位字节数据存放在低地址，低位字节数据存放在高地址，这种内存存储方式叫做大端对齐