C++知识点分析--03(适合有基础的C语言)

一、引用的本质。

本质：引用的本质在C++内存实现其实就是一个指针常量。

#include <iostream>
using namespace std;

void func(int &ref)
{
	ref = 100;  // 内部发现ref是一个引用，等价于  *ref = 100
}

int main(int argc,char *argv[])
{
	int a = 10;

	//系统看到这句话之后，会自动转换成 int * const ref = &a;
	//ref是指针常量，一旦把&a这个地址赋值给ref这个指针之后，ref就不能指向别的东西。
	//这也解析了为什么引用初始化了值之后，不能修改。
	int &ref = a;   //  int * const ref = &a;

	//系统内部发现ref是引用，自动帮我们将这句话转换为： *ref = 20
	ref = 20;   //  *ref = 20

	cout << "a = " << a << endl;    //20
	cout << "ref = " << ref << endl;//20   // cout << *ref << endl;

	func(a);

	cout << "a = " << a << endl;    //100
	cout << "ref = " << ref << endl;//100  

	return 0;
}

二、常量引用。

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

#include <iostream>
using namespace std;

void show_value(const int &val)   //const int &val = a
{
	//val = 180;
	cout << "val = " << val << endl;
}

int main(int argc,char *argv[])
{
	//常量引用。
	//使用场景： 一般都是修饰形参。
	
	//int &ref = 10;  //错误
	//引用必须要引用一块合法的空间，如果这样写是可以的话，那么将来ref=20，肯定也是可以的，但是这样做，
	//不就是10=20，那么就相当于给常量赋值。

	const int &ref = 10;   //正确   -> 看不到原名
	//加了const之后，编译器将代码修改为：
	/*
	int temp = 10;
	const int &ref = temp;
	ref -> 别名
	temp -> 原名    -> 看得到原名
	*/

	//ref = 20;  //因为发现ref是一个常量引用，所以不能给ref赋值。

	int a = 170; //身高
	show_value(a);

	return 0;
}

三、函数提高。 — 函数默认参数。

在C++中，函数的参数列表中的形参可以有默认值的。
语法： 返回值类型 函数名(参数=默认值){}

#include <iostream>
using namespace std;

//函数默认参数
//语法： 返回值类型 函数名(参数=默认值){}
int func(int a,int b,int c = 30)
{
	return a + b + c;
}

//注意事项：
//1. 如果某一个位置已经有默认参数了，那么从这个位置开始往后，从左到右都必须有默认值。
int func2(int a,int b = 10,int c = 30,int d = 40)  //如果b有默认参数了，那么c与d必须要有默认参数，不给就是错。
{
	return a + b + c + d;
}

//2. 如果函数声明有默认参数了，那么函数实现不能有默认参数
//   如果函数声明没有默认参数了，那么函数实现就可以有默认参数
//函数声明
int func3(int a,int b);

//函数的实现过程
int func3(int a = 10,int b = 20)
{
	return a + b;
}

int main(int argc,char *argv[])
{
	//cout << func(10,20,30) << endl;
	cout << func(10,20) << endl;   //a = 10  b = 20  c默认=30

	cout << func2(10) << endl;     //a = 10  b默认=10  c默认=30  d默认=40

	//如果某一个参数有默认值了，然后你又传参了，那么按你的传参来计算。
	cout << func2(10,20) << endl;  //a = 10  b默认=20  c默认=30  d默认=40

	cout << func3() << endl;

	return 0;
}

四、函数占位参数。

C++中函数的形参列表可以有占位参数，用来做占位，调用函数时必须填补该位置。
语法： 返回值类型 函数名(数据类型){}
在现阶段函数的占位参数存在意义不大，但是后面的文章中会使用到该技术。

#include <iostream>
using namespace std;

//占位参数
//返回值类型 函数名(数据类型){}
int func(int a,int = 20)
{
	return a;
}

int main()
{
	//调用函数时必须填补该位置.
	//cout << func(10) << endl;
	cout << func(10,10) << endl;

	//如果占位参数有默认值，则不需要填补该位置。
	cout << func(10) << endl;

	return 0;
}

五、函数重载。

1、函数重载的作用是什么？
函数名相同，提高复用性。

2、函数重载的满足条件：
1）同一个作用域下。
2）函数名称相同。
3）函数参数类型不同、个数不同、顺序不同。

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

#include <iostream>
using namespace std;

/*
函数重载的满足条件：
1）同一个作用域下。
2）函数名称相同。
3）函数参数类型不同 或者 个数不同 或者 顺序不同。

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

void func()
{
	cout << "func()的调用" << endl;
}

void func(int a)
{
	cout << "func(int a)的调用" << endl;
}

void func(double b)
{
	cout << "func(double b)的调用" << endl;
}

void func(int a,double b)
{
	cout << "func(int a,double b)的调用" << endl;
}

void func(double b,int a)
{
	cout << "func(double b,int a)的调用" << endl;
}

/*  函数的返回值不可以作为函数重载的条件
int func(double b,int a)    -> 如果调用fun(3.14,10)就会出现二义性
{
	cout << "func(double b,int a)的调用" << endl;
}
*/

int main(int argc,char *argv[])
{ 
	//func();   //调用第一个      
	//func(10); //调用第二个
	//func(3.14); //调用第三个
	//func(10,3.14); //调用第四个
	func(3.14,10); //调用第五个

	return 0;
}

六、函数重载注意事项。

1、引用作为重载条件。
2、函数重载碰到函数默认参数了。

#include <iostream>
using namespace std;

//函数重载注意事项
//1、引用作为重载条件。
void func(int &a)  //int &a = 10
{
	cout << "func(int &a)的调用" << endl;
}

void func(const int &a)  //const int &a = 10
{
	cout << "func(const int &a)的调用" << endl;
}

//2、函数重载碰到函数默认参数了。
void func2(int a)
{
	cout << "func2(int a)的调用" << endl;
}

void func2(int a,int b = 10)
{
	cout << "func2(int a,int b = 10)的调用" << endl;
}

int main(int argc,char *argv[])
{
	int a = 10;
	func(a);  //调用的是第一个
	func(10);  //调用的是第二个

	//func2(10);  //出现了二义性
	func2(10,10);  //调用的是第二个

	return 0;
}