C++程序的内存模型

代码区：存放函数体的二进制代码，由操作系统进行管理

全局区：存放全局变量和静态变量以及常量

栈区：由编译器自动分配释放，存放函数的参数值，局部变量

堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

在程序编译后，生成了exe可执行程序，未执行改程序前分为两个区，一个是代码区一个是全局区

1.代码区

写的所有代码都在代码区，全是2进制数。程序运行前分配的区域。、

1.存放CPU执行的机器指令

2.代码区是共享的，共享的目的是对于频繁执行的程序，只需在内存中有一份即可

3.代码区是只读的，使其只读的原因是防止程序意外的修改了他的指令

2.全局区

程序允许前就有了全局区

1.全局变量和静态变量存放于此。

2.全局区还包含了常量区，字符串常量和其他常量（const修饰的变量）也存放于此。

3.改区域的数据在程序结束后由操作系统释放。

代码一

验证全局变量和局部变量不在同一个地方

#include <iostream>
using namespace std;
// 全局变量
int c = 10;
int d = 20;

int main()
{
	int a = 10; //局部变量 在函数体里面的都是局部变量
	int b = 10;

	cout << "局部变量a的地址" << &a << endl;
	cout << "局部变量b的地址" << &b << endl;

	cout << "全局变量c的地址" << &c << endl;
	cout << "全局变量d的地址" << &d << endl;

	system("pause");
	return 0;
}

演示结果如下

代码二

验证全局变量与静态变量是否都在全局区

代码

#include <iostream>
using namespace std;
// 全局变量
int c = 10;
int d = 20;

int main()
{
	int a = 10;         //局部变量 在函数体里面的都是局部变量
	int b = 10;
	static int e = 10;  // 在普通变量前加static就变成静态变量
	static int f = 10;  // 在普通变量前加static就变成静态变量
	cout << "局部变量a的地址" << &a << endl;
	cout << "局部变量b的地址" << &b << endl;

	cout << "全局变量c的地址" << &c << endl;
	cout << "全局变量d的地址" << &d << endl;

	cout << "全局变量e的地址" << &e << endl;
	cout << "全局变量f的地址" << &f << endl;

	system("pause");
	return 0;
}

演示结果如下

 

结果显示全局变量与静态变量在同一个区都在全局区

代码三

由于常量分为字符串常量和const修饰的常量因此我们分开来说

验证字符串常量是否与静态变量和全局变量一样都在全局区里面。

#include <iostream>
using namespace std;
// 全局变量
int c = 10;
int d = 20;
//  const修饰的全局变量
const int g = 10;
const int h = 20;
 // 常量 字符串常量“ABCHG”
 //       const 修饰的常量  const修饰的全局变量  const修饰的局部变量
int main()
{
	int a = 10;         //局部变量 在函数体里面的都是局部变量
	int b = 10;
	static int e = 10;  // 在普通变量前加static就变成静态变量
	static int f = 10;  // 在普通变量前加static就变成静态变量

	cout << "局部变量a的地址" << &a << endl;
	cout << "局部变量b的地址" << &b << endl;

	cout << "全局变量c的地址" << &c << endl;
	cout << "全局变量d的地址" << &d << endl;

	cout << "静态变量e的地址" << &e << endl;
	cout << "静态变量f的地址" << &f << endl;

	cout << "字符串常量的地址" << &("hello world") << endl;

	// cout << " const修饰的全局变量g的地址" << &g << endl;
	// cout << " const修饰的全局变量h的地址" << &h << endl;

	system("pause");
	return 0;
}

结果展示

我们发现字符串常量与全局变量和静态变量都在全局区

 代码四

验证const修饰的变量是否在全局区

const修饰全局变量，const修饰局部变量

#include <iostream>
using namespace std;
// 全局变量
int c = 10;
int d = 20;
//  const修饰的全局变量
const int g = 10;
const int h = 20;
 // 常量 字符串常量“ABCHG”
 //       const 修饰的常量  const修饰的全局变量  const修饰的局部变量
int main()
{
	int a = 10;         //局部变量 在函数体里面的都是局部变量
	int b = 10;
	static int e = 10;  // 在普通变量前加static就变成静态变量
	static int f = 10;  // 在普通变量前加static就变成静态变量

	const int k = 10;  // const修饰的局部变量
	const int r = 10;  // const修饰的局部变量

	cout << "局部变量a的地址" << &a << endl;
	cout << "局部变量b的地址" << &b << endl;

	cout << "全局变量c的地址" << &c << endl;
	cout << "全局变量d的地址" << &d << endl;

	cout << "静态变量e的地址" << &e << endl;
	cout << "静态变量f的地址" << &f << endl;

	cout << "字符串常量的地址" << &("hello world") << endl;

	 cout << " const修饰的全局变量g的地址" << &g << endl;
	 cout << " const修饰的全局变量h的地址" << &h << endl;

	 cout << " const修饰的局部变量k的地址" << &k << endl;
	 cout << " const修饰的局部变量r的地址" << &r << endl;

	system("pause");
	return 0;
}

结果如下 

我们发现const修饰的全局变量与字符串常量，静态变量，全局变量都离得很近（都是002B开头）因此他们都在全局区。而const修饰的局部变量和普通的局部变量都没在全局区。

局部变量与局部常量在一起存放栈区。

结论：全局变量，静态变量，字符串常量，const修饰的全局变量都存放在全局区。

3.栈区

程序允许后才会有栈区。

由编译器自动分配释放，存放函数的参数值，局部变量等。

栈区的数据由编译器管理开辟和释放。

注意：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放。

代码

#include <iostream>
using namespace std;

// 不要返回局部变量地址
int* func()
{
	int a = 10;// 这个数据是局部变量，存放在栈上，栈区的数据在函数执行完后自动释放
	return &a;
}


int main()
{
	int* p = func();
	cout << *p << endl;    // 第一次可以打印正确的数据，因为编译器做了保留
	cout << *p << endl;    // 第二次这个数据就不在保留被编译器清除，这个内存被释放了
	system("pause");
	return 0;
}

运行后发现

第一次打印的是正确的第二次就是乱码了，原因就是执行完这段函数，编译器先做了一个保留，因此第一次显示是正确的，但是这个函数执行完，改内存就要被释放，因此在打印该数据就是乱码了。

形参也会放在栈上

void func (int b);  // 这个b也放在栈上，这个函数执行完，改内存就被释放

 总结：1.栈区存放的是局部变量和const修饰的局部变量，还有形参

  2.不要返回局部变量的地址，因为局部变量在执行完后就会被释放，因此在访问改地址就是非法操作了。

4.堆区

程序允许后才会有堆区

由程序员分配释放，若程序员不释放，程序结束后由操作系统回收在C++中主要利用new在堆区开辟内存。

代码

#include <iostream>
using namespace std;

int* func()
{
	// int p =10发现是在栈区的，程序执行完就自动释放，如果我们不想释放怎么办
	// 那就用new关键字在堆区开辟一个内存 规则就是new 数据类型(改地址的值)  new int(10)
	// 这个 new 数据类型（该地址的值）返回的是一个指针，因此需要用指针去接受他
	int* p = new int(10); //指针 本质也是局部变量，放在栈上，指针保存的数据是放在堆区的
	return p;
}
int main()
{
	int* p1 = func();
	cout << *p1 <<endl;    // 打印数值
	cout << *p1 << endl;    // 打印数值
	cout << *p1 << endl;    // 打印数值
	cout << *p1 << endl;    // 打印数值
	system("pause");
	return 0;
}

结果如下

我们发现在堆区的这个数据在程序执行完后不会被释放。

在这里有几点要说明一下

1.堆区的创建   new 数据类型（数值）

int * p = new int(10);

new创建的这个数据一定要用指针来接受，因为他返回的是一个指针。如上图用p来接受new返回的指针，改地址的值是10。

2.在该函数里面局部变量 p也是局部函数，在运行完就会释放。但是为什么他的数据在后面打印没有像栈区那样乱码。

第一栈区是创建一个变量a，赋值给10，然后把a的地址给返回回去，因为局部函数在执行完后，都会被释放，main函数里面的指针p接受到a的地址后，在打印第二遍时，由于局部函数执行完成，局部变量被释放，因此main函数里面的指针p，由于他里面的地址保存的是局部变量a的地址，在局部变量被释放后，a的地址就是野指针，因此对p进行解引用就是乱码

为什么堆区没有乱码？

堆区通过new关键字在堆区创建一个内存，该堆区的地址返回给局部变量p；在main函数里面

用p1接受返回的p的地址，p1接受到的地址其实是堆区里面数字10的地址，由于堆区的释放与创建是程序员控制的所有，程序员只要不释放那么这个数字10就不会被释放。因此可以一直打印。

总结：1.堆区数据由程序员管理开辟和释放的

           2.堆区数据利用new关键字进行开辟内存

5.new运算符

C++中利用new操作符在堆区开辟数据

堆区开辟的数据，由程序员手动开辟，手动释放，释放利用关键字delete；

语法 new 数据类型

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

代码

#include <iostream>
using namespace std;
// 1.new的基本语法
int* func()
{
	// 在堆区创建整形数据
	// new返回的是该类型的指针
	int* p = new int;
	*p = 20;
	return p;
}


int main()
{
	int* p = func();
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	// 堆区的数据由程序员管理开辟与释放
	delete p;
	// cout << *p << endl;

	system("pause");
	return 0;
}

在delete后，在访问该数据就会引起异常，因为内存已经被释放，在操作就是非法操作。 

在堆区利用new开辟数组

new int(10);//创建一个变量，该变量的值是10

new int[10];  //创建一个数组数组里面存放10个变量

用new int[10]返回的是这段内存的首地址

代码

实现创建new int[10]，并且访问和赋值

#include <iostream>
using namespace std;
int* func()
{
	int* p = new int[10];
	return p;
}
//可以直接当数组使用
void test()
{
	int* p = func();
	for (int i = 0; i < 10; i++)
	{
		p[i] = 100 + i; // 赋值
	}
	for (int i = 0; i < 10; i++)
	{
		cout << p[i] << endl;
	}
	//数组的释放
	delete[] p;
}

int main()
{
	test();
	system("pause");
	return 0;
}

结果