C++ 基础【05】

本文代码仓库地址： gitee码云CSDN笔记仓库地址

---

---

学习 内存

// 内存 -- 堆区
#include <iostream>
using namespace std;

int* fun01() {
	// 利用 new关键字 可以将数据开辟到堆区
	// 释放利用操作符 delete
	// 指针 本质也是局部变量 存放在栈上，指针保存的数据是在堆区的【new出来的】

	// new int(666) 这是存放在堆区的，代码不让它释放它会一直存在，直至程序关闭
	// int* p 这是存放在栈区的，是程序自动开辟和释放
	// 后面返回值p 指向的地址是 new int(666) 的地址，所以不会出现返回的地址被自动释放

	int* p = new int(666);
	return p;
}

int* fun02() {
	// 不要返回 局部变量的地址，因为局部变量的地址是程序控制的，放在栈区
	// 函数执行完成后，内存会释放

	// 下面的变量都是局部变量，在函数fun02()执行完成,变量也会随之释放
	// 然后，返回的地址可能已经被占用，随之下面打印的值是不对的

	int a = 999;
	int* p = &a;
	return p;
}

int* fun03() {
	// 在new一个数组的时候需要用 []

	int* arr = new int[10];
	for (int i = 0; i < 10; i++)
	{
		arr[i] = i;
	}
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	return arr;
}

int main() {

	int* p1 = fun01();
	int* p2 = fun02();
	cout << "函数中new的" << *p1 << endl;
	cout << "函数中new的" << *p1 << endl;
	// 释放 p1 指向的地址的内存
	delete p1;
	// 内存已经被释放，再次操作就是非法操作，会报错
	// cout << "函数中new的" << *p1 << endl;
	cout << endl;
	cout << "函数中的局部变量" << *p2 << endl;
	cout << "函数中的局部变量" << *p2 << endl;

	int* p3Arr = fun03();
	// 释放数组的内存需要在 delete 后面加[]
	delete[] p3Arr;


	cout << endl;
	system("pause");
	return 0;
}

---

学习 引用

// 引用：本质就是一个【指针常量】
#include <iostream>
using namespace std;


// 引用传递，交换两个参数
void fun01(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}

// 引用做函数的返回值，不要返回局部变量的引用
int& fun02() {
	int a = 0;
	// 这里会有警告
	return a;
}

// 引用做函数的返回值
int& fun03() {
	// 静态变量，存放在全局区，全局区的数据再程序结束后释放
	static int a = 666;
	return a;
}

void fun04(const int& val) {
	// 不加const下面的代码可以运行，这样导致的结果是形参val和实参xy2都发生了改变
	// val = 888;
	cout << "val = " << val << endl;
}


int main() {

	int a = 101;
	cout << endl;
	// 引用 语法：数据类型& 别名 = 原名【这个时候a和b都是指向同一个内存】
	int& b = a;
	cout << "修改前 a = " << a << endl;
	cout << "修改前 b = " << b << endl;
	b = 666;
	cout << "修改b后 a = " << a << endl;
	cout << "修改b后 b = " << b << endl;
	// 引用必须初始化
	// int& c;
	int d = 202;
	// 引用一旦初始化就不可以改变指向
	// int& b = d;
	// 这是在赋值，不是改变指向
	b = d;
	cout << endl;
	cout << "再次赋值后的 a = " << a << endl;
	cout << "再次赋值后的 b = " << b << endl;
	cout << "再次赋值后的 d = " << d << endl;

	cout << endl;
	int e = 666;
	int f = 999;
	fun01(e, f);
	cout << "经过引用传递过后的 e = " << e << endl;
	cout << "经过引用传递过后的 f = " << f << endl;

	int& aa = fun02();
	// 第一次打印正确是因为IDE做了临时保留
	cout << aa << endl;
	cout << aa << endl;
	cout << endl;

	int& bb = fun03();
	cout << bb << endl;
	cout << bb << endl;
	cout << endl;
	// 引用做函数返回值就相当于 静态变量 a 的本身
	// 此时的 fun03 就可以等价于 静态变量 a 的本身，这里进行新的赋值，等价于静态变量本身新的赋值
	fun03() = 666666;
	// 而 bb 又是引用的静态变量 a(a的别名bb)
	cout << bb << endl;
	cout << bb << endl;
	cout << endl;
	// 上面的 bb 引用就相当于 cc 引用 bb 一样【这可能就是所谓的套娃吧】
	int& cc = bb;
	cout << "cc引用bb后的 cc = " << cc << endl;
	fun03() = 99999;
	cout << "再次给fun03()赋新的值后的 bb = " << bb << endl;
	cout << "再次给fun03()赋新的值后的 cc = " << cc << endl;
	// 上面的这一系列的赋值、引用都相当于在操作静态变量a的值和给其起别名【可以认为是：某人有多个外号】

	cout << endl;
	// 常量引用
	// 引用必须应用一块合法的内存空间
	// int& xy1 = 10;
	// 加上const之后，IDE理解的代码就是 int temp = 10; int& xy1 = temp;
	const int& xy1 = 10;

	int xy2 = 555;
	fun04(xy2);
	cout << "xy2 = " << xy2 << endl;

	cout << endl;
	system("pause");
	return 0;
}

---

学习 函数

// 函数
#include <iostream>
using namespace std;


// 带默认值的函数【带默认值的参数后面还有参数那么后面（右）的参数也必须带默认值】
void fun01(int a, int b = 20, int c = 30) {
	cout << a + b + c << endl;
}

// 声明和实现只能有一个带默认参数
void fun02(int a, int b, int c = 10);
void fun02(int a, int b, int c) {
	cout << a + b + c << endl;
}

// 函数重载【在同一个作用域下、函数名相同、参数类型不同或者类型不同】
void fun02() {
	cout << "调用了这个重载的函数" << endl;
}


int main() {

	fun01(10, 10);
	fun02(5, 10);
	fun02();

	cout << endl;
	system("pause");
	return 0;
}

---

一点点笔记，以便以后翻阅。