内存分区模型、引用、函数的默认、站位参数及重载

C++程序在执行时大概分为四个区域：

1.代码区：存放函数体的二进制代码，由操作系统进行管理；

2.全局区：存放全局变量、静态变量、常量；

3.栈区：由编译器自动分配释放，存放函数的参数值、局部变量等等；

4.堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统释放；

不同区域的数据，赋予不同的生命周期，给我们带来了更大的灵活编程。

程序运行前

在程序编译后，生成了exe可执行程序，执行该程序前分为两个区域：代码区与全局区

代码区的特点是“共享的”、“只读的”；存放cpu执行的机器指令；

全局区：存放了全局变量（在函数体外的变量）、静态变量（在普通变量之前添加static变成静态变量）、常量【（分为字符串常量）、（const就是的变量）】，该区域的数据在程序结束后由操作系统释放。

程序运行后

栈区 ：由编译器自动分配释放，存放函数的参数值、局部变量等等；

注意事项：不要返回局部变量的地址，栈开辟的数据由编译器自动释放

堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统释放；

在C++中主要利用new在堆区开辟内存，释放时使用delete操作符

利用new创建的数据会返回该数据对应类型的指针

#include <iostream>
using namespace std;
int* func()
{
	//在堆区创建整形数据
	//利用指针接收new返回的地址
	int* p = new int(10);
	return p;
}
//1.new的基本语法
void test01()
{
	int* p = func();
	cout << *p << endl;
	//如果要释放程序员开辟的数据，利用关键字delete
	delete p;
	//cout << *p << endl; //内存被释放，再次访问属于非法操作，会报错
}
//2.在堆区利用new开辟数组
void test02()
{
	//创键含有10个数的整形数组
	int* arr = new int[10]; // 10代表数组中有10个元素
	for (int i = 0; i < 10; i++)  //给数组赋值
	{
		arr[i] = i + 100;
	}
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
}
int main() {
	test01();
	test02();

	system("pause");
	return 0;
}

二.引用

1.引用的作用：给变量起别名      基本语法 ： 数据类型  &别名  = 原名

引用必须初始化，且初始化之后不能更改

#include <iostream>
using namespace std;
int main() {
	//引用的基本语法 ：数据类型  &别名 = 原名
	int a = 10;
	//创建引用
	int& b = a; //属于引用的初始化，且不能再出现&b = c的情况
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	system("pause");
	return 0;
}

2.值传递、地址传递、引用传递却别

#include <iostream>
using namespace std;
void swap01(int a, int b)
{
	a = 20;
	b = 10;
}
void swap02(int *a, int *b)
{
	*a = 20;
	*b = 10;
}
void swap03(int & a, int & b)
{
	a = 20;
	b = 10;
}
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;
}

3.常量引用

在函数列表中，用const修饰形参，防止形参改变实参。

#include <iostream>
using namespace std;
void swap01( const int &a)
{
	//a = 20; //在加上const之后，再去修改形参便会报错；
	cout << "a = " << a << endl;
}

int main() {

	int a = 10;
	swap01(a);
	system("pause");
	return 0;
}

函数的默认参数

C++中函数的形参列表中形参时可以有默认值的

语法：返回值类型 函数名（形参=默认值） {}

#include <iostream>
using namespace std;
//函数的默认参数
//在形参有默认值的情况下，如果我们自己传入数据，那么用我传入的数据，如果没有传入数据就用默认值
//语法： 返回值类型  函数名  （形参 = 默认值） {}
int func(int a ,int b=20,int c=30)
{
	return a + b + c;
}
 //注意事项：如果某个位置有了默认参数，那么这个位置以后，从左到右必须有默认值
//即如果参数b有了默认值，那么c必须有默认值，a可有可无，，如果c有了，a,b可有可无


//如果声明有了默认参数，那么实现就不能有默认参数，反之亦然
// 声明与实现两者只能有一个默认参数
int func2(int a = 10, int b = 10);  //函数的声明

int func2(int a, int b)   //函数的实现
{
	return a + b;
}

int main() {
	func(10, 10, 30);
	func2();
	system("pause");
	return 0;
}

函数的占位参数

C++函数的形参列表中可以有占位参数，用来占位，调用时必须填补该位置

语法：返回值类型  函数名 （数据类型） {}

现阶段占位参数的意义不大，后面会深入讲解

#include <iostream>
using namespace std;
void func(int a, int)
{
	cout << "占位参数" << endl;
}
int main() {
	func(10, 10);  //调用函数时必须将参数补全
	system("pause");
	return 0;

}

函数的重载

函数名可以相同，提高复用性

函数重载满足条件：

1.同一作用域下  2.函数名相同  3.函数参数的类型不同 或 个数不同 或 顺序不同

注意：函数的返回值不同不可以作为函数重载的条件

#include <iostream>
using namespace std;
void func(int a)
{
	cout << "调用func（int a）函数" << endl;
}
void func()
{
	cout << "调用func函数" << endl;
}
void func(double a, int b)
{
	cout << "func(double a,int b)" << endl;
}
void func(int a, double b)
{
	cout << "func(int a ,double b)" << endl;
}

//int func(int a, double b)  {} //返回值类型不能做重载的条件
int main() {
	func(10);  //调用第一个函数
	func();  //调用第二个函数
	func(10, 20.1);  //调用第四个函数
	func(20.1,10);   //调用第三个函数
	system("pause");
	return 0;
}

函数重载的注意事项：
1.引用作为函数重载的条件

2.当函数重载遇到默认参数时，容易产生二义性，尽量在函数重载时使用默认参数

#include <iostream>
using namespace std;
//引用作为函数重载的条件
void func(int &a)
{
	cout << "func(int &a)" << endl;
}
void func(const int& a)
{
	cout << "func(const int &a )" << endl;
}
 //两者可以形成重载，条件是形参的数据类型不同


int main() {
	int a = 10;
	func(a);  //调用第一个函数
	func(10);  //调用第二个函数
	system("pause");
	return 0;
}