C++学习 --内存四区

目录

1， 内存四区

1-1， 代码区

1-1-2， 特点

1-2， 全局区

1-2-1， 全局变量

1-2-2， 静态变量

1-2-3， 全局常量

1-3， 栈区

1-4， 堆区

1-4-1， new单个对象

1-4-2， delete单个对象

1-4-3， new&delete数组

---

1， 内存四区

四区中的数据，具有不同生命周期

1-1， 代码区

代码区存放的是编译后的C++代码二进制文件

1-1-2， 特点

其特点是共享、只读， 共享是只内存中的该段二进制文件可以反复执行，只读是指存放后的二进制文件不能被修改。

1-2， 全局区

全局区存放的是C++代码的全局变量， 静态变量， 全局常量， 字符串常量的地方， 程序结束后由操作系统释放

1-2-1， 全局变量

全局变量为在函数外定义的变量

#include <iostream>
#include <string>

using namespace std;

/*全局变量存放在全局区，程序运行结束后由操作系统释放*/

//定义全局变量
int global_a = 10;
int global_b = 10;

int main()
{
	int local_a = 10;
	int local_b = 20;

	cout << "局部变量的地址local_a：" << &local_a <<endl;
	cout << "局部变量的地址local_b：" << &local_b <<endl;
	cout << "全局变量的地址global_a：" << &global_a << endl;
	cout << "全局变量的地址global_b：" << &global_b << endl;

	system("pause");

	return 0;
}

------------------------------------------------------------------
输出结果：
局部变量的地址local_a：00000045BEB5F9E4
局部变量的地址local_b：00000045BEB5FA04
//可以看出全局变量的地址与局部变量的地址不在一片内存空间
全局变量的地址global_a：00007FF74F00D000
全局变量的地址global_b：00007FF74F00D004

1-2-2， 静态变量

通过static 数据类型  变量名方式， 定义的变量为静态变量

#include <iostream>
#include <string>

using namespace std;

/*静态变量存放在全局区，程序运行结束后由操作系统释放*/

int global_a = 10;
int global_b = 10;

int main()
{
	//定义静态变量
	static int local_static_a = 10;
	static int local_static_b = 20;

	cout << "全局变量的地址global_a：" << & global_a << endl;
	cout << "全局变量的地址global_b：" << &global_b << endl;
	cout << "静态变量的地址local_static_a：" << &local_static_a << endl;
	cout << "静态变量的地址local_static_b：" << &local_static_b << endl;

	system("pause");

	return 0;
}
-----------------------------------------------------
输出结果：
//可以看出全局和静态变量存放在同一块内存区中
全局变量的地址global_a：00007FF60391D074
全局变量的地址global_b：00007FF60391D078
静态变量的地址local_static_a：00007FF60391D07C
静态变量的地址local_static_b：00007FF60391D080

1-2-3， 全局常量

在函数体外通过const 数据类型 变量名， 可定义一个全局常量

#include <iostream>
#include <string>

using namespace std;

/*全局常量，字符串常量存放在全局区，程序运行结束后由操作系统释放*/

int global_a = 10;
int global_b = 10;

//定义全局常量
const int c_global_a = 10;
const int c_global_b = 10;

int main()
{
    //定义局部常量
	const int local_a = 10;
	const int local_b = 20;
	cout << "全局变量的地址global_a：" << & global_a << endl;
	cout << "全局变量的地址global_b：" << &global_b << endl;
	cout << "全局常量的地址c_global_c：" << &c_global_a << endl;
	cout << "全局常量的地址c_global_d：" << &c_global_b << endl;
	//&"aaaaa"表示获取该字符串常量的地址
	cout << "字符串常量的地址：" << &"aaaaa" << endl;
	cout << "局部常量的地址：" << &local_a << endl;
	cout << "局部常量的地址：" << &local_b << endl;

	system("pause");

	return 0;
}
----------------------------------------------------------------
输出结果：
//可以看出， 全局变量， 全局常量在同一块内存空间
全局变量的地址global_a：00007FF60F63D074
全局变量的地址global_b：00007FF60F63D078
全局常量的地址c_global_c：00007FF60F63ABB0
全局常量的地址c_global_d：00007FF60F63ABB4
字符串常量的地址：00007FF60F63ACA8
//可以看出局部常量与上面的常量不在一块内存空间
局部常量的地址：0000004A3B11F634
局部常量的地址：0000004A3B11F654

1-3， 栈区

栈区存放的是C++代码的函数的参数， 局部变量， 由编译器自动分配和释放。

注意：不要返回局部变量的地址， 因为局部变量在函数调用完后， 就被编译器释放。 

#include <iostream>
#include <string>

using namespace std;

/*局部变量和形参都是存放在栈区，由编译器分配和释放*/
int * func(int b)
{
	int a = 10;

	return &a;
}

int main()
{
	int* p = func();
	cout << "调用func:" << *p << endl;

	system("pause");

	return 0;
}
---------------------------------------------------
输出结果：
//因为局部变量调用完后， 就被释放了， 所以这里没有获取到局部变量a的值
//同理形参b也一样
第一次调用func:-858993460

1-4， 堆区

堆区是由程序员分配和释放的， 若程序员不主动释放，在程序结束后由操作系统释放

1-4-1， new单个对象

通过new 数据类型(对象)， 可在堆区创建一个地址，对象为地址指向的值， 返回指定数据类型的指针

#include <iostream>
#include <string>

using namespace std;

/*堆区的数据是由程序员分配的，若不主动释放，在程序
运行完成后， 由操作系统释放*/

int * func()
{
	//通过new方式在堆区创建一块地址，返回对应数据类型的指针
    //地址存的数据是10
	int* p = new int(10);

	return p;
}

int main()
{
	int* p = func();
	cout << "调用func：" << *p << endl;
	cout << "调用func：" << *p << endl;

	system("pause");

	return 0;
}
-----------------------------------------------------
//能打印出10， 是因为10是存放在堆区上， 不会因为func调用完成后而释放
调用func：10
调用func：10

1-4-2， delete单个对象

通过delete 指针， 可手动释放堆区指定的内存空间

#include <iostream>
#include <string>

using namespace std;

/*堆区的数据是由程序员分配的，若不主动释放，在程序
运行完成后， 由操作系统释放*/

int * func()
{
	//通过new方式在堆区创建一块地址，地址存的数据是10
	//局部变量p，任然在栈区
	int* p = new int(1011);

	return p;
}

int main()
{
	int* p = func();
	cout << "调用func：" << *p << endl;

    //通过delete手动释放堆区的地址
	delete p;
	//该行调用，会报错，因为p指向的值已经被释放
	cout << "调用func：" << *p << endl;

	system("pause");

	return 0;
}
-----------------------------------------------------------
输出结果：
调用func：1011
//这里没有输出的因为是因为p已经被手动释放
调用func：

1-4-3， new&delete数组

通过new 数据类型[长度]， 可在堆区创建一块数组地址空间， 通过delete[] 指针， 可手动释放创建的地址空间

#include <iostream>
#include <string>

using namespace std;


int * func()
{
	//表示在堆区中创建一个大小为10数组地址空间, 并赋值给指针arr
	int* arr = new int[10];

	//数组赋值
	for (int i = 0; i < 10; i++)
	{
		arr[i] = i;
	}

	return arr;
}

int main()
{
	int* arr = func();
	
	//逐个打印数组元素
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	//delete[]表示释放的是一个数组地址空间
	delete[] arr;

	system("pause");

	return 0;
}
-------------------------------------------------------------------
输出结果：
0 1 2 3 4 5 6 7 8 9