02.C++进阶笔记

---

前文：基础笔记：C++基础笔记

---

※内存模型

1、程序的内存模型

内存分区模型：C++程序在执行时，将内存大方向划分为4个区域(划分区域是为了给数据赋予不同的生命周期，提高编程的灵活性)。

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

2、程序运行前各区域内存状态

代码区：

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

全局区：

• 存放全局变量、静态变量、常量（const修饰的全局常量和字符串常量）
• 该区域的数据在程序结束后由操作系统释放。

内存中变量位置分布

3、程序运行后各区域内存状态

栈区：

• 由编译器自动分配释放，存放函数的参数值，局部变量等。
• 注意：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放，再次操作会非法操作导致异常。

#include <iostream>
using namespace std;
 
int * fun()
{
    
    int p = 24;
    return &p;
}

int main()
{
    int *p = fun();
    cout << "p："<< *p << endl; //这里输出2次 是因为有时候编辑器存在保留 第一次能正常输出
    cout << "p："<< *p << endl;
    return 0;
}

堆区：

• 由程序员分配释放，若程序员不释放，结束时由操作系统回收。
• 在C++中主要利用new关键字，将数据在开辟在堆区。
• 指针本质也是局部变量，放在栈中，指针保存的数据是存放在堆区。

#include <iostream>
using namespace std;
 
int * fun()
{
    int * p = new int(24);
    return p;
}

int main()
{
    int *p = fun();
    cout << "p："<< *p << endl;
    cout << "p："<< *p << endl;
    cout << "p："<< *p << endl;
    return 0;
}

4、new操作符

• C++中利用new操作符在堆区开辟数据。
• 堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete。
• new关键字语法：new 数据类型
• delete关键词语法：delete 数据名 delete[] 数组名
• 利用new创建的数据，会返回该教据对应的类型的指针。

#include <iostream>
using namespace std;
 
int * fun()
{
    int *p =new int(24); //创建数组是 int *p = new arr[10]; 创建长度为10的数组
    return p;
}

int main()
{
    int *p = fun();
    cout << "p："<< *p << endl; 
    cout << "p："<< *p << endl;
    delete p; //释放数组内存是 delete[] arr;
    cout << "p："<< *p << endl; //因为已经通过delete释放了该内存，再次操作会导致异常
    cout << "p："<< *p << endl;
    return 0;
}

※引用

1、引用的基本语法

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

#include <iostream>
using namespace std;

int main()
{
	int a = 202408;
    int &b = a; //给变量a修改名字为b
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	b = 2024; 
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	return 0;
}

2、引用注意事项

• 引用必须初始化(给变量起别名，要声明给哪个变量起别名)
• 引用一旦初始化后，不可以改变。

#include <iostream>
using namespace std;

int main()
{
	int a = 2024;
	int b = 2025;
    int &c = a; // int &c; 的写法是错误的，因为没有初始化，不知道哪个变量名起了别名。
	c = b; // 引用初始化后，不能在进行修改，现在的操作相当于赋值，将b的值赋给c，要想再次修改名字，需要用其他的引用，比如int &d = c。
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	cout << "c =" << c << endl;
	return 0;
}

为了方便理解，画图解释一下，方块为内存。

3、引用做函数参数

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

#include <iostream>
using namespace std;

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

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

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

int main()
{
	int a = 2024;
	int b = 2025;
	Swap1(a,b);//值传递，局部变量中数值发生了交换，实际地址中的值并没有发生改变，即形参不会修饰实参。
	cout << "a =" << a << " b =" << b << endl;
	Swap2(&a,&b);//地址传递，通过操作地址进行交换，值发生改变，即形参会修饰实参。
	cout << "a =" << a << " b =" << b << endl;
	Swap3(a,b);//引用传递，相当于别名，直接操作地址中的变量，值发生改变，即形参会修饰实参。
	cout << "a =" << a << " b =" << b << endl;
	return 0;
}

4、引用做函数返回值

• 作用：引用是可以作为函数的返回值存在的
• 注意：不要返回局部变量引用
• 用法：函数调用作为左值

#include <iostream>
using namespace std;

int& test1()
{
	int a = 2024;
	return a;
}

int& test2()
{
	static int a = 2024;
	return a;
}

int main()
{
	int &Test1 = test1(); //此时test1()中的变量属于局部变量，存放在栈区，在执行后已经被释放，不在存在返回值的内存
	cout << "Test1 =" << Test1 << endl; //执行错误
	
	int &Test2 = test2();	//此时test2()中的变量属于静态变量，存放在全局区，程序结束后才释放，存在返回值的内存地址，所以可以
	cout << "Test2 =" << Test2 << endl;//可以正常执行
	
	test2()=2025; //函数的返回值是引用类型，这个函数调用可以作为左值，此时相当于是变量a的别名test2()，即在操作a地址的内容，所以此时a的内容变成2025
	cout << "Test2 =" << Test2 << endl;//可以正常执行
	return 0;
}

5、引用的本质

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

#include <iostream>
using namespace std;

void test(int& t) //引用类型，编译器会转换为 int* const t = &a;
{
	t = 2025;// 编译器转换为*t=2025，即别名为t的a地址中的变量改为2025。
}

int main()
{
	int a = 2024;
	int& b = a; //编译器转换为 int* const b = &a; 由于引用的本质是一个指针常量，而指针常量的指针指向不可更改，所以引用不可更改。
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	test(a);
	cout << "t =" << a << endl;
	return 0;
}

6、引用的本质

• 作用：常量引用主要用来修饰形参，防止误操作。
• 方法：在函数形参列表中，使用const关键字修饰形参，防止形参改变实参。

#include <iostream>
using namespace std;

void x(int& a) //由于参数是引用类型，修改形参会导致实参也改变，void x(const int& a) 带上const关键字就能避免形参误修改实参的问题
	{
		a = 2025; //上面函数形参带上const关键字后，此句函数会报错，提醒程序员修改了实参。
		cout << "a1 = " << a << endl;
	}

int main()
{
	/*
		int & a = 2024; 
		是错误的 因为引用必须引一块合法的内存空间 常量2024没有明确的内存空间 
		const int & a = 2024; 
		加上const关键字 编辑器会产生一个临时地址 上方的代码相当于变成了 int b = 2024; const int & a = b; 有了合法的内存空间
    	此时进行修改a，例 a = 2025; 也是错误的，因为const关键字是常量，无法修改数据，此方法通常用于函数中防止形参改变实参
	*/
	int a = 2024;
	x(a);
	cout << "a2 = " << a << endl;
    return 0;
}

※函数高级

※类和对象

---

后续内容等有空在更新，摸会儿鱼。。。