C++学习笔记——程序的内存模型

本文带来C++的内存模型，干货多多！

1 内存分区模型

C++程序在执行时，将内存大方向划分为4个区域

• 代码区：存放函数体的二进制代码，由操作系统进行管理的（所有的代码及注释）
• 全局区：存放全局变量和静态变量以及常量
• 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
• 堆区：有程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

内存四区的意义：
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编码

1.1 程序运行前

在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域：代码区和全局区

代码区：

• 存放CPU执行的机器指令（就是你写的代码）
• 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
• 代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令

全局区：

• 全局变量和静态变量存放在此
• 全局区还包含了常量区，字符串常量和其他常量（const修饰的变量即常量）也存放在此
• 该区域的数据在程序结束后由操作系统释放

#include<iostream>
#include<string>
using namespace std;

//全局变量
int g_a = 10;
int g_b = 10;

//const修饰的全局变量，即全局常量，全局常量在常量区
const int c_g_a = 10;
const int c_g_b = 10;

int main() {

	// 全局区
	// 全局变量、静态变量、常量（字符串常量和全局常量）

	//创建普通局部变量
	int a = 10;
	int b = 10;
	cout << "局部变量a的地址为：" << (int)&a << endl;
	cout << "局部变量b的地址为：" << (int)&b << endl;
	cout << "全局变量g_a的地址为：" << (int)&g_a << endl;
	cout << "全局变量g_b的地址为：" << (int)&g_b << endl;

	// 静态变量 在普通变量前面加static，数据静态变量
	static int s_a = 10;
	static int s_b = 10;
	cout << "静态变量s_a的地址为：" << (int)&s_a << endl;
	cout << "静态变量s_b的地址为：" << (int)&s_b << endl;
	
	//常量
	//字符串常量
	cout << "字符串常量hello地址为：" << (int)&"hello" << endl;
	cout << "字符串常量world地址为：" << (int)&"world" << endl;

	//const修饰的变量
	//const修饰的全局变量，const修饰的局部变量
	cout << "全局常量c_g_a的地址为：" << (int)&c_g_a << endl;
	cout << "全局常量c_g_b的地址为：" << (int)&c_g_b << endl;

	//const修饰的局部变量，即局部常量,局部常量不在常量区，也不在全局区
	//局部常量存放在栈区
	const int c_l_a = 10;// c - const g - global  l - local
	const int c_l_b = 10;
	cout << "局部常量c_l_a的地址为：" << (int)&c_l_a << endl;
	cout << "局部常量c_l_b的地址为：" << (int)&c_l_b << endl;

	system("pause");
	return 0;
}

总结：

• c++中在程序运行前分为全局区和代码区
• 代码区特点是共享和只读
• 全局区中存放全局变量、静态变量、常量
• 常量区中存放const修饰的全局常量和字符串常量
• const修饰的局部常量放在栈区（同普通局部变量一个位置）

1.2 程序运行后

栈区：

• 由编译器自行分配和释放，存放函数的参数值，局部变量等
• 注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自行释放（在函数执行完后自行释放）

//栈区数据注意事项 -- 不要返回局部变量的地址
//栈区的数据由编译器管理开辟和释放


int * func(int b) {//形参数据也会放在栈区
	b = 100;
	int a = 10;//局部变量存放在栈区，存放在栈区，栈区的数据在函数执行完后自行释放
	return &a;//返回局部变量的地址
}

int main() {
	//接受func函数的返回值
	int * p = func(1);

	cout << *p << endl;//第一次可以打印正确的数字，是因为编译器给我们做了一次保留
	cout << *p << endl;//第二次这个数据就不再保留了

	system("pause");
	return 0;
}

堆区：

• 由程序员分配释放，若程序员不释放，程序运行期间，该内存不会被释放，程序结束时由操作系统回收
• 在C++中利用new在堆区开辟内存

int * func() {
	//利用new关键字，可以将数据开辟到堆区
	//指针 本质也是变量，放在栈上，指针保存的数据是放在堆区
	int * p = new int(10);//返回的是地址
	return p;
}

int main() {
	
	//在堆区开辟数据
	int * p = func();//得到func返回的地址，保存在main函数区部变量中（也在堆区），当main函数运行结束后，这个func返回的局部变量地址才会消除
	cout << *p << endl;
	cout << *p << endl;

	system("pause");
	return 0;
}

总结：

• 堆区数据由程序员管理开辟和释放
• 堆区数据利用new关键字进行开辟内存

1.3 new操作符

• C++中利用new操作符在堆区开辟数据
• 堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete

语法：new 数据类型
利用new创建的数据，会返回该数据对应的类型的指针

//1、new的基本语法
int * func() {
	//在堆区创建整型数据
	//new返回的是 该数据类型的指针
	int * p = new int(10);
	return p;
}

void test01() {
	int * p = func();
	cout << *p << endl;
	cout << *p << endl;
	//堆区的数据 由程序员管理开辟，程序员管理释放
	//如果释放堆区的数据，利用关键字delete
	delete p;
	cout << *p << endl; //内存已经被释放，再次访问就是非法操作，会报错
}

//2、在堆区利用new开辟数组
void test02() {
	//创建10整型数据的数组，在堆区
	int * arr = new int[10];//10代表数组有10个元素
	for (int i = 0; i < 10; i++)
		arr[i] = i + 100;
	for (int i = 0; i < 10; i++)
		cout << arr[i] << endl;
	//释放堆区数组
	//释放数组的时候，要加[]才可以
	delete[] arr;
}

int main() {
	
	//test01();
	test02();
	system("pause");
	return 0;
}

2 几个重要结论

2.1 结论1

结论1：当调用函数时，其实就相当于对传入实参进行了拷贝，存放在栈中（局部变量），具体如下（见示例1）：

• 当传入值时，拷贝值存放在栈中
• 当传入指针时，拷贝指针的地址存放在栈中
• 当传入引用时，和传入指针原理是一样的，因为引用本身是由指针常量实现的（即指针的指向不可以修改，指针指向的值是可以修改的）

另外，需要注意的是：简短的赋值操作不属于拷贝，赋值操作只是把原有内存空间换成了别的值，所以拷贝只是在函数调用时存在，可以看下面的实例2.

示例1：

#include<iostream>
#include<string>
using namespace std;

void func(int a) {
	cout << "func(int a)中a的地址：" << (int)&a << endl;
}
void func1(int *a) {
	cout << "func1(int *a)中a的地址：" << (int)a << endl;
	cout << "func1(int *a)中指针a本身存放的地址：" << (int)&a << endl;

}
void func2(int &a) {
	cout << "func2(int &a)中a的地址：" << (int)&a << endl;
}

int g_a = 10;
int main() {
	cout << "（全局区）全局变量g_a的地址：" << (int)&g_a << endl;
	int l_a = 10;
	cout << "（栈区）局部变量l_a的地址：" <<(int)&l_a<< endl;
	func(g_a);
	func(l_a);
	func1(&l_a);
	func2(l_a);
	/*
	结论1：当调用函数时，其实就相当于对传入实参进行了拷贝，存放在栈中（局部变量），具体有以下情况：
	- 当传入值时，拷贝值存放在栈中
	- 当传入指针时，拷贝指针的地址存放在栈中
	- 当传入引用时，和传入指针原理是一样的，因为引用本身是由指针常量实现的（即指针的指向不可以修改，指针指向的值是可以修改的）
	*/
	system("pause");
	return 0;
}

示例2：

int main() {

	//下面赋值前后a的地址是一样的
	int a = 10;
	cout << "a的地址为：" << (int)&a << endl;

	a = 20;
	cout << "值更改后a的地址为：" << (int)&a << endl;


	system("pause");
	return 0;
}

2.2 结论2

结论2，全局区中全局变量和静态变量在一个区域，全局常量和字符串常量在一个区域。全局变量和静态变量可以读写（即可以更改），全局常量和字符串常量只能读，不能写。在全局区的常量区（全局常量和字符串常量）中，数值只存在一份，而全局变量区（全局变量和静态变量），相同数值可以有多个（方法是多创建几个数值相同的变量）。见示例1

除了作用域外，全局变量区（全局变量和静态变量）和局部变量区（栈区）是一样的，都可以读写，多个值相同的变量拥有不同的内存空间。

另外，所有的字面量（包括字符串字面量和其他字面量）都是常量，存放在全局区中的常量区中，不能进行写操作，而引用是为了给变量其别名，为了对变量的内存空间进行读写操作（必须有一个合法的内存空间，可以读写的空间都可以，堆区，栈区，全局变量区），所以把变量赋给引用，而不能是字面量。如果是只读的引用，则把字面量赋给引用也是合法的，见示例2。

要记住，创建一个局部变量（指针变量、数值变量，后面结论3会更详细说），存放在栈区，而引用只是给变量起别名，不是创建变量，所以引用的右侧位置只能放变量

// 全局区
// 全局变量、静态变量、常量（字符串常量和全局常量）

//全局变量
int g_a = 10;
int g_b = 10;

//const修饰的全局变量，即全局常量
const int c_g_a = 10;
const int c_g_b = 10;
int main() {

	cout << "全局区变量地址为：" << endl;
	cout << "全局变量g_a的地址为：" << (int)&g_a << endl;
	cout << "全局变量g_b的地址为：" << (int)&g_b << endl;

	static int s_a = 10;
	static int s_b = 10;
	cout << "全局区静态变量地址为：" << endl;
	cout << "静态变量s_a的地址为：" << (int)&s_a << endl;
	cout << "静态变量s_b的地址为：" << (int)&s_b << endl;


	cout << "全局区普通常量地址为：" << endl;
	cout << "全局常量c_g_a的地址为：" << (int)&c_g_a << endl;
	cout << "全局常量c_g_b的地址为：" << (int)&c_g_b << endl;

	cout << "全局区字符串常量地址为：" << endl;
	cout << "字符串常量hello地址为：" << (int)&"hello" << endl;
	cout << "字符串常量world地址为：" << (int)&"world" << endl;
	cout << "字符串常量hello地址为：" << (int)&"hello" << endl;

	//结论2，全局区中全局变量和静态变量在一个区域，全局常量和字符串常量在一个区域。
	//全局变量和静态变量可以读写（即可以更改），全局常量和字符串常量只能读，不能写

	system("pause");
	return 0;
}

示例2：

int main() {
	//int &p = 10;//读写的引用，不合法的，因为这个字面量10放在常量区里面，不可以进度写
	//只读的引用，合法的
	const int &c = 10;

	int a = 10;
	//引用右侧放变量，合法
	int &b = a;

	cout << b << endl;
	cout << c << endl;
	
	system("pause");
	return 0;
}

2.3 结论3

结论3（很重要）：

• 所有的局部变量(一般为指向一片内存空间的指针的内存地址)存放在栈区，当然数据型局部变量也在栈区
• 所有的全局变量(一般为指向一片内存空间的指针的地址)存放在全局变量区，当然数据型全局变量也在全局变量区
• 如果在局部作用域中new一个数据(数值或数组），new出来的数据的内存空间在堆区，而指向该内存空间的指针的地址在栈区
• 如果在全局作用域中new一个数据(数值或数组），new出来的数据的内存空间在堆区，而指向该内存空间的指针的地址在全局变量区
• 在局部作用域中用如char * s = "hello"创建出来的字符串，该字符串的内存空间在全局常量区，而指向该字符串内存空间的指针的地址(即s的地址)在栈区，故该字符串的内存空间是只读不可写的，而指向该字符串内存空间的指针的地址是可以被重新写入的（即重新赋值，看结论1的注意事项）
• 在局部作用域中用如char arr[] = "hello"创建出来的数组字符串，该字符串的内存空间在栈区，该字符串内存空间的指针的地址(即arr的地址)也在栈区，这个是需要注意的地方，所以，该字符串的内存空间是可读可写的，并且内存空间由编译器自动释放。
• 在局部作用域中用如char *newarr = new char[6]创建的数组，该数组的内存空间在堆区，而指向数组内存空间的指针的地址在栈区，该数组的内存空间需要由程序员释放，指向数组内存空间的指针的地址(内存空间)由编译器自动释放。
• 在全局作用域用如int * global_newArr = new int[20]创建的数组，该数组的内存空间在堆区，而指向数组内存空间的指针的地址在全局变量区，该数组的内存空间需要由程序员释放，指向数组内存空间的指针的内存空间由编译器自动释放。

示例：

#include<iostream>
#include<string>
using namespace std;

int * global_newArr = new int[20];

int main() {

	//int型局部变量
	int a = 10;
	cout << "栈区的地址为：" << (int)&a << endl;

	cout << "全局常量区的地址为：" << (int)&"hello" << endl;
	

	int * p = new int(10);
	cout << "堆区的地址为：" << (int)p << endl;
	cout << "指向堆区内存空间的指针(变量)的地址为：" << (int)&p << endl;


	char * s = "hello";
	cout << "字符串的地址为：" << (int)s << endl;
	cout << "指向该字符串内存空间的指针的地址为：" << (int)&s << endl;
	//s[3] = 'z'; 报错，全局常量区只能读，不能写

	char arr[] = "hello";
	cout << "数组字符串的地址为：" << (int)arr << endl;
	cout << "指向该数组字符串内存空间的指针的地址为：" << (int)&arr << endl;
	//arr[3] = 'z';不报错，数组字符串存放在堆区，可读可写


	char *newarr = new char[6];
	cout << "new数组的地址为：" << (int)newarr << endl;
	cout << "指向new数组内存空间的指针的地址为：" << (int)&newarr << endl;

	cout << "global_newArr的地址为：" << (int)global_newArr << endl;
	cout << "指向global_newArr内存空间的指针的地址为：" << (int)&global_newArr << endl;

	delete p;
	delete[] newarr;
	delete[] global_newArr;

	system("pause");
	return 0;
}

2.4 结论4(sizeof统计空间大小)

关于数组字符串和指针字符串所占空间大小，无论指针字符串长度多少，使用sizeof统计的大小始终为4个字节，因为统计的是指针的大小。而对于数组字符串，使用sizeof统计的是整个字符串空间的大小。

#include<iostream>
#include<string>
using namespace std;

int main() {
	char * a = "abcefg";
	char b[] = "abcefg";
	cout << "a:" << sizeof(a) << endl;
	cout << "b：" << sizeof(b) << endl;

	system("pause");
	return 0;
}