c++学习笔记9核心编程

核心编程

本阶段主要针对c++面向对象编程技术做详细讲解

1内存分区模型

c++程序执行时，将内存大方向分为4个区域：
1）代码区：存放函数的二进制代码，由操作系统进行管理
2）全局区：存放全局变量和静态变量以及常量
3）栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
4）堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

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

释放：删除内存空间里面的数据

1.1程序运行前

在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域
代码区：
存放CPU执行的机器指令（存放内容）
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外的修改了它的命令**（在exe文件中不可改）**

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

int g = 10;//全局变量
const int c_a = 10;//const修饰的全局常量
int main()
{
	//创建普通局部变量
	int a = 10;
	cout << "局部变量a的地址为：" << (int)&a << endl;//加int转十进制
	cout << "全局变量g的地址为：" << (int)&g << endl;
	
	static int s_a = 10;//静态变量：在普通变量前面加static
	cout << "静态变量s_a的地址为：" << (int)&s_a << endl;

	//常量
	//1、字符串常量
	cout << "字符串常量的地址为：" << (int)&"hello world" << endl;
	
	//2、const修饰的变量：const修饰的全局变量，称为全局常量；const修饰的局部变量，称为局部变量
	cout << "全局常量的地址为：" << (int)&c_a << endl;
	const int c_b = 10;
	cout << "局部常量的地址为：" << (int)&c_b << endl;

总结：
c++中在程序运行前分为全局区和代码区
代码区的特点是共享和只读
全局区存放全局变量、静态变量、常量
常量区中存放const修饰的全局变量和字符串变量

1.2程序运行后

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

int * func()
{
      int a = 10;//局部变量 存放在栈区，栈区数据在函数执行完后自动释放
      return &a;//返回局部变量的地址
}
int main()
{
int * p = func();//接收func函数的返回值
cout<<*p<<endl;//输出数字10，是因为第一次编译器做了保留
cout<<*p<<endl;//输出乱码，是因为第二次数据就不再保留

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

int* func()
{
	int * p = new int(10);//利用new关键字可以开辟到堆区
	//指针本质也是局部变量，放在栈上，指针保留的数据是放在堆区
	return p;
}
int main()
{
	//在堆区开辟数据
	int* p = func();
	cout << *p << endl;

1.3new操作符

在c++中主要利用new在堆区开辟内存
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
语法：new 数据类型
利用new创建的数据，会返回该数据对应的类型的指针
指针本质也是局部变量，放在栈上，指针保留的数据是放在堆区

int * p = new int(1);
float * p = new float(1);
double * p = new double(1）；

//new的基本语法
int* func()
{
	int * p = new int(10);
	return p;
}

void test01()
{
	int* a = func();
	cout << *a << endl;
	delete a;//删除p里面的数据
	cout << *a << endl;//数据已经被删除，即内存已经被释放，再运行即为非法操作
}

//在堆区利用new开辟数组
void test02()
{
	int * arr = new int[10];//代表一个数组有10个元素
	for (int i = 0; i < 10; i++)
	{
		arr[i] = i + 100;//给10个元素赋值100~109
	}   //指针本质也是局部变量，放在栈上，指针保留的数据是放在堆区
	delete[] arr;//释放堆区数组，要加[]才可以
}

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

		system("pause");
		return 0;
}

2引用

2.1引用的基本使用

作用：给变量取别名
语法： 数据类型 &别名 = 原名

int a = 10;
int &b = a;
b = a = 10;
b = 20;
a = b = 20;

2.2引用的注意事项

1）引用必须要初始化；

int &b;//为错误操作

2）引用在初始化之后，不可以改变；

int a = 10;
int b = 20;
int &c = a;
c = b ;//操作正确，为赋值操作
int &c = b;//操作错误，引用在初始化之后，不可以改变；

2.3引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参

//交换函数

//1、值传递法
void exchange01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
}

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

//3、引用传递
void exchange03(int &c, int &d)
{
	int temp = c;
	c = d;
	d = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	exchange01(a, b);//值传递，形参不会修饰实参
	exchange02(&a, &b);//地址传递，形参修饰实参
	exchange03(a, b);//引用传递，形参修饰实参
	//int &c = a; int &d = b;

2.4引用做函数的返回值

作用：引用是可以作为函数的返回值存在的
注意：不要返回局部变量引用
用法：函数调用作为左值（左值即等号左边的值）

int& test（）
{
static a = 10;
return a;//返回a的引用
}
int main()
{
int &ref = test();
test() = 1000;
//此时，ref = a = 1000;

注：如果函数的返回值是引用，这个函数调用可以作为左值

2.5引用的本质

本质：引用的本质在c++内部实现是一个指针常量。

int & ref = a;//相当于int * const p = a;
ref = 20;//相当于 *p=20

2.6常量引用

作用：常量引用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参改变实参

int a = 10; int & ref = 10 ;  错误
const int & ref = 10; 正确，加const后，编译器将代码修改为：int temp = 10; const int & ref = temp;
引用必须引用一块合法的内存空间
ref = 20；错误，加入const后变为只读，不可以进行修改