C++自学笔记007（面向对象起始）

C++自学笔记007（面向对象起始）

1、内存分区模型

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

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

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

1.1程序运行前

在程序编译后，生成了.exe可执行程序，未执行该程序前分为两个区域
（1）代码区（存放CPU执行的机器指令）
特点：代码区共享的，对于频繁操作的程序，只需要一份代码即可
代码区是只读的，在程序执行时，代码区是不可修改的
（2）全局区（全局变量和静态变量存放在此）
全局区还包含了常量区，主要存放字符串常量和其他常量（const常量）

//全局区解释

#include <iostream>
using namespace std;

//c--const  g--global  l--local

//全局变量（在main函数外定义的常规变量）
int g_a = 10;
int g_b = 10;

//const修饰的全局变量
const int c_g_a = 10;
const int c_g_b = 10;

int main()
{
	//全局区（全局变量、静态变量、常量）
	
	//创建普通局部变量（在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 << "字符串常量的地址为：" << (int)&"hello world!" << endl;
	//const修饰的常量（const修饰的全局常量、const修饰的全局变量）
	//const修饰的局部变量
	const int c_l_a = 10;
	const int c_l_b = 10;

	cout << "const修饰的局部变量c_l_a的地址为：" << (int)&c_l_a << endl;
	cout << "const修饰的局部变量c_l_b的地址为：" << (int)&c_l_b << endl;

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



	system("pause");
	return 0;
}

代码结果：

结论：

• C++中在运行前分为全局区和代码区；
• 代码区特点是共享和只读；
• 全局区存放全局变量、静态变量和常量，其中常量只包括const修饰的全局常量 和 字符串常量；

1.2 程序运行后

栈区：
由编译器自动分配释放，存放函数的参数值、局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据有编译器自动释放

#include <iostream>
using namespace std;

int* func(int b)
{
	b = 10; //局部变量也存放在栈区
	int a = 10; //局部变量  存放在栈区，栈区的数据在函数执行后自动释放
	return &a;
}

int main()
{
	//接受func函数的返回值
	int *p = func();
	cout << *p << endl; //第一次打印正确是因为编译器会保留一次数据
	cout << *p << endl; //第二次编译器就不保留了

	system("pause");
	return 0;
}
```代码结果：
![](https://img-blog.csdnimg.cn/20201009110111942.png#pic_center)
**堆区**
由程序员分配释放，若程序员不释放，程序结束时由操作系统释放
在C++中利用new在堆区开辟内存

```cpp
#include <iostream>
using namespace std;

int* func()
{
	int *a = new int(10); //new可以在堆区开辟新内存，new语句返回的是新开辟内存的地址，所以需要赋值给指针变量
	return a;
}

int main()
{
	int *p = func();
	cout << *p << endl;
	
	system("pause");
	return 0;
}

手动释放内存
开辟新内存来建立数组

#include <iostream>
using namespace std;

int* func()
{
	int *p = new int(10);
	return p;
}

void test01()
{
	int *a = func();
	cout << *a << endl;
	cout << *a << endl;
	delete a; //手动释放堆区内存

	//cout << *a << endl; //因为内存已释放，所以会报错
}

void test02()
{
	//在栈区创建10整型主句的数组
	int *arr = new int[10]; //int[]中括号代表开辟数组内存
	
	for(int i = 0; i < 10; i++)
	{
		arr[i] = i + 100; //给10个元素赋值100~109
	}

	for(int j = 0; j < 10; j++)
	{
		cout << arr[i] << endl;
	}
	//释放堆区的数组内存要在delete 后面加[]
	delete[] arr;
}

int main()
{
	test01();
	test02();

	system("pause");
	return 0;
}

2、引用

2.1 引用的基本使用

作用：本质就是给变量起别名
格式：数据类型 &别名 = 原名；
范例代码：

#include <iostream>
using namespace std;

int main()
{
	//引用（给变量起别名）
	//格式：数据类型 &别名 = 原名；
	int a = 10;
	int &b = a; //创建引用
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	b = 20;
	cout << "change a = " << a << endl; //给别名赋新的值，原名变量的值会随着一起改变
	cout << "change b = " << b << endl;


	system("pause");
	return 0;
}

代码结果：

2.2 引用的注意事项

（1）引用必须初始化
（2）引用在初始化后就不能在进行任何更改

2.3 引用做函数参数

作用：函数传输参数时，可以利用引用技术啊让形参修改实参
优点：可以简化指针传参的地址传递，即直接用应用技术进行传参，从而避免使用复杂的指针变量（值传递、地址传递、引用传递）

代码解释

#include <iostream>
using namespace std;

//值传递
void swap01(int a, int b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}

//地址传递
void swap02(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

//引用传递
void swap03(int &a, int &b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 10;
	int b = 20;
	
	//swap01(a, b); //值传递不可以改变实参的值
	//swap02(&a, &b); //地址传递可以改变实参的值
	swap03(a, b); //引用传递可以改变实参的值

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;


	system("pause");
	return 0;
}

啊啊啊啊，开课题要做软件，C++白学了呜呜呜，明天开始转战C#。。。。。。