C++核心编程——内存分区、引用、函数提高和函数重载

本专栏记录C++学习过程包括C++基础以及数据结构和算法，其中第一部分计划时间一个月，主要跟着黑马视频教程，学习路线如下，不定时更新，欢迎关注。
当前章节处于：
---------第1阶段-C++基础入门
---------第2阶段实战-通讯录管理系统，
====>第3阶段-C++核心编程，
---------第4阶段实战-基于多态的企业职工系统
---------第5阶段-C++提高编程
---------第6阶段实战-基于STL泛化编程的演讲比赛
---------第7阶段-C++实战项目机房预约管理系统

一、 内存分区

C++程序在执行时，内存大致方向分为4个区域，不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程。代码区和全局区是在程序运行前，栈区和堆区是在代码运行后

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

1.1 代码区

存放CPU执行的机器指令

• 代码区是共享的，只需要在内存中有一份代码即可
• 代码区是只读的，防止程序意外地修改了它的指令

1.2 全局区

全局变量和静态变量存放在此。
全局区还包括了常量区，字符串常量和其他常量也存放在这里。
该区域的数据在程序结束后由操作系统释放。

#include <iostream>
using namespace std;
// 全局变量 ----- 全局区
int g_a = 0;
int g_b = 0;
// 全局常量 ----- 全局区
const int c_g_a = 0;
const int c_g_b = 0;
int main() {
	// 以下为全局区
	// 全局变量
	cout << "全局变量a的地址为" << (int)&g_a << endl;
	cout << "全局变量b的地址为" << (int)&g_b << endl;
	// 全局常量
	cout << "全局常量a的地址为" << (int)&c_g_a << endl;
	cout << "全局常量b的地址为" << (int)&c_g_b << endl;
	// 静态变量
	static int s_a = 0; // static修饰的是静态变量
	static int s_b = 0;
	cout << "静态变量a的地址为" << (int)&s_a << endl;
	cout << "静态变量b的地址为" << (int)&s_b << endl;
	// 字符串常量
	cout << "字符串常量a的地址为" << (int)&"Hallo world" << endl;


	// 以下为非全局区
	// 局部变量
	int l_a = 0;
	int l_b = 0;
	cout << "局部变量a的地址为" << (int)&l_a << endl;
	cout << "局部变量b的地址为" << (int)&l_b << endl;
	// 局部常量
	// const修饰的常量
	const int c_l_a = 0;
	const int c_l_b = 0;
	cout << "局部常量a的地址为" << (int)&l_a << endl;
	cout << "局部常量b的地址为" << (int)&l_b << endl;

	system("pause");
	return 0;

}

全局变量a的地址为1109844336
全局变量b的地址为1109844340
全局常量a的地址为1109830576
全局常量b的地址为1109830580
静态变量a的地址为1109844344
静态变量b的地址为1109844348
字符串常量a的地址为1109831072
局部变量a的地址为1807742644
局部变量b的地址为1807742676
局部常量a的地址为1807742644
局部常量b的地址为1807742676
请按任意键继续. . .

可以看到全局变量，全局常量，静态变量，字符串常量是存储在全局区，其他量存储在非全局区。

1.3 栈区

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

1.4 堆区

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

#include <iostream>
using namespace std;

int* func() {
	int* p = new int(10);  // new关键字在堆区域开辟地址
	return p;
}
int main() {
	
	cout << *func() << endl;
	cout << *func() << endl;
	cout << *func() << endl;
	system("pause");
	return 0;

}

10
10
10
请按任意键继续. . .

new操作符
利用new操作符开辟数据
堆区开辟的数据，有程序员手动开辟，手动释放，释放使用delete
利用new创建的数据，会返回该数据对应的类型的指针

#include <iostream>
using namespace std;

int* func() {
	int* p = new int(10);  // new关键字在堆区域开辟地址
	return p;
}
int main() {
	
	cout << *func() << endl;
	int* p = func();
	cout << *p << endl;
	// 删除操作
	delete p;
	// cout << *p << endl; 会报错，原因是p已经从堆区域删除
	system("pause");
	return 0;

}

new在堆区开辟一个数组

#include <iostream>
using namespace std;
int* test() {
	int *arr = new int[10]; // new创建数组
	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 *arr = test();
	delete[] arr; // 删除数组时要加上[]表示删除的是一个数组
	system("pause");
	return 0;

}

0
1
2
3
4
5
6
7
8
9
请按任意键继续. . .

二. 引用

2.1 引用的基本使用

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

#include <iostream>
using namespace std;


int main() {
	int a = 0;
	// 引用
	int& b = a;
	cout << "a=" << a<<endl;
	cout << "b=" << b<<endl;
	int* p = &a;
	cout << "p的值为：" << *p << endl;
	b = 10; // 同样也会修改a的值
	cout << "p的值为：" << *p << endl;
	cout << "a的值为：" << a << endl;

	cout << "a的地址为：" << (int)&a << endl;
	cout << "b的地址为：" << (int)&b << endl;
	system("pause");
	return 0;

}

a=0
b=0
p的值为：0
p的值为：10
a的值为：10
a的地址为：-289408796
b的地址为：-289408796
请按任意键继续. . .

注意事项：

• 引用必须初始化
• 引用在创建之后就不可改变了

int &a; // 错误 未初始化！


int a = 0;
int c = 0;
// 引用
int& b = a;
int& b = c; // 报错,创建之后就不可以更改

2.2 引用做函数参数

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

#include <iostream>
using namespace std;
void swap(int &a,int&b) {
	int temp = a;
	a = b;
	b = temp;
}

int main() {
	int a = 10;
	int b = 20;
	cout << "交换前a=" << a << endl;
	cout << "交换前b=" << b << endl;
	swap(a, b);
	cout << "交换后a=" << a << endl;
	cout << "交换后b=" << b << endl;
	system("pause");
	return 0;

}

交换前a=10
交换前b=20
交换后a=20
交换后b=10
请按任意键继续. . .

引用传递和地址传递效果一样，都可以对实参进行修改。

2.3 引用做函数返回值

#include <iostream>
using namespace std;
// 不要返回局部变量的引用
//int &test() {
//	int a = 10;
//	cout <<"a的地址:"<< (int)& a << endl;
//	return a;
//}

int &test() {
	static int a = 10; // 静态变量  在全局区
	cout <<"a的地址:"<< (int)& a << endl;
	return a;
}
// 引用的格式
// int & a = b;
int main() {
	int& ref = test();

	cout << "ref的地址" << (int) & ref << endl;
	cout << "ref的地址为：" << ref << endl;
	system("pause");
	return 0;

}

a的地址:1526331140
ref的地址1526331140
ref的地址为：-858993460
请按任意键继续. . .

函数的调用可以作为左值：

#include <iostream>
using namespace std;
int& test() {
	static int a = 10;// 静态变量
	return a;
}

int main() {
	int& b = test();
	cout << "b的值为：" << b<<endl;
	test() = 1000;  // 函数调用作为左值
	cout << "b的值为：" << b<<endl;
	system("pause");
	return 0;

}

b的值为：10
b的值为：1000
请按任意键继续. . .

2.4 引用的本质

引用的本质是在C++内部实现一个指针常量，由编译器内部完成
指针常量是指针的指向不可改变，但指针指向的值可以改变

#include <iostream>
using namespace std;
void test(int& x) {
	cout << x << endl;
}

int main() {
	int a = 0;
	int &b = a;  // 相当于指针常量 int const *b  = &a;  指向对象不能变，指向对象的值能变
	b = 10; // 相当于*b =10  解引用
	cout << "a的值为：" << a << endl;
	cout << "b的值为：" << b << endl;
	system("pause");
	return 0;

}

a的值为：10
b的值为：10
请按任意键继续. . .

2.5 常量引用

主要用来修饰形参，防止误操作，使用const修饰形参，防止形参修改实参

#include <iostream>
using namespace std;
void printValue(const int& a) {
	//a = 100; const修饰后不可再函数内部进行更改，防止误操作
	cout << a << endl;
}

int main() {
	int a = 10;
	printValue(a);
	system("pause");
	return 0;

}

10
请按任意键继续. . .

在写函数内部具体代码时，应该先判断是否需要使用const修饰，防止后续代码有误操作。

三. 函数提高

3.1 函数的默认参数

默认参数可以不传值，也可以重新传值进行覆盖。
注意事项:

• 如果某个位置有默认参数，那么从这个默认参数后都应该有默认参数
• 如果函数申明有默认参数，那么函数实现就不能有默认参数,两者只能有其一，防止重定义

#include <iostream>
using namespace std;
// 设置函数默认参数
int func(int a, int b = 20, int c = 30) {
	return a + b + c;
}
// 注意事项
// 1. 如果某个位置有默认参数，那么从这个默认参数后都应该有默认参数
// int a, int b = 20, int c; 错误

// 2.如果函数申明有默认参数，那么函数实现就不能有默认参数,两者只能有其一，防止重定义
//int func2(int a = 10, int b = 10);
//int func2(int a = 20, int b = 30) {
//	return a + b;
//}


int main() {
	cout << func(10,30) << endl;
	system("pause");
	return 0;

}

70
请按任意键继续. . .

3.2 占位参数

用于占位，调用函数时必须填补该位置，也可以设置默认参数，意义不大，但后续会用到。
语法: 返回值类型 函数名 (数据类型) {}

#include <iostream>
using namespace std;
void func(int a, int) {
	cout << a << endl;
}

int main() {
	func(1, 2);
	system("pause");
	return 0;

}

1
请按任意键继续. . .

四. 函数重载

作用：函数名可以相同，提高复用性
需要满足如下条件：

1. 同一个作用域
2. 函数名称相同
3. 函数参数类型不同或者 个数不同 或者顺序不同
   函数的返回值不可作为函数重载的条件

#include <iostream>
using namespace std;

void func() {
	cout << "hallo world" << endl;
}
void func(int a) {
	cout << "hallo world" << endl;
}
int main() {
	func();
	system("pause");
	return 0;

}

抓住重载条件即可，函数参数类型不同或者 个数不同 或者顺序不同
引用作为函数重载条件：

#include <iostream>
using namespace std;
void test1(int& a) {  // int&a =10 不合法
	cout << "调用的test1 int& a！" << endl;
}
void test1(const int& a) {// const int&a =10 不合法
	cout << "调用的test1！ const int& a" << endl;
}


int main() {
	int a = 10;
	test1(a);
	test1(10);
	system("pause");
	return 0;

}

调用的test1 int& a！
调用的test1！ const int& a
请按任意键继续. . .

函数重载遇到默认参数情况

#include <iostream>
using namespace std;

void test1(int a,int b=10) {
	cout << "调用int a,int b=10" << endl;
}
void test1(int a) {
	cout << "调用int a" << endl;
}
int main() {
	// test1(10); // 报错
	test1(10,20); // 不报错
	system("pause");
	return 0;

}

调用int a,int b=10
请按任意键继续. . .