【C++笔记2】初识C++（函数重载概念、示例；引用概念、特性、引用与权限）

所有运行结果均在VS2022，Debug,x86的环境下得出

一、函数重载

1.相关概念

• C语言不支持函数重载，但C++支持

• 是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

• 在不同作用域中，不存在函数重载这个概念

• 函数返回值不同，与是否函数重载没有关系

• 注意有时候的报错，是产生了”调用歧义“，而非”不支持函数重载“

2.函数重载示例

2.1参数类型不同

代码示例 ：

int Add(int left, int right)      
{
	cout << "int Add(int left, int right)" << endl;        
	return left + right;        
}
//这两个函数的参数类型不同，一个是int类型的，一个是double类型的        
double  Add(double left, double right)        
{
	cout << " double Add(double left,double right)" << endl;
	return left + right;        

2.2参数个数不同

代码示例 ：

void f(int a,int b)  
{
	cout << "f()" << endl;  
}
//参数个数不同  
void f(int a)  
{
    cout <<" f(int a) "<< endl;  
}

2.3参数类型顺序不同

代码示例：

void f(int a, char b)          
{
	cout << "f(int a,char b)" << endl;          
}
//这里是参数类型顺序不同          
void f(char b, int a)          
{
	cout << "f(char b, int a)" << endl;          
}

2.4C语言不支持重载原因

• C语言：同名函数没办法区分。
• C++：是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

二、引用

1.引用概念

1.1概念

• 引用不是新定义一个变量，而是给已存在变量取了一个别名。
• 编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
• 引用类型必须和引用实体是同种类型的

1.2 代码示例

语法：类型& 引用变量名(对象名) = 引用实体；

void TestRef()                                
{
int a = 10;                                
int& ra = a;//<====定义引用类型                                
printf("%p\n", &a);                                
printf("%p\n", &ra);                               
}

2.引用特性

2.1 引用在定义时必须初始化

引用相当于给变量取别名，“定义时未初始化就引用”相当于“先取了外号再找与外号相合适的人”，这是不合理的，有违常识的。

代码如下：

void Test()     
{
int a = 10;     
// int& ra; // 该条语句编译时会出错     
int& ra = a;     
int& rra = a;     
printf("%p %p %p\n", &a, &ra, &rra);    

2.2一个变量可以有多个引用

这句话可以理解为：一个人可以有多个外号，多个别名。
我们常常是需要多少个，就取多少个别名，就引用多少次。

2.3引用一旦引用一个实体，再不能引用其他实体

2.31代码示例如下

int main()
{
	int x = 0;
	int& y = x;
	int z = 1;
	// y变成z的别名呢？
	// 还是z赋值给y
	y = z;

	return 0;
}

2.31代码调试如下

可见，z赋值给y了。

2.4 引用与权限

2.41正常引用

int main()
{
	int x = 1;
	int& y = x;

	return 0; 
}

2.42权限的放大

int main() intmain（） 
{
	const int x = 1; 常量 x=1; 
	int& y = x;//会报错 

	return 0; 
}

x加const修饰之后，只能读，不能被编辑，
而y能写也能读，权限被放大，故不能使用，故报错。

2.43权限的缩小

int main()
{
	 int x = 1;
	const int& y = x;
	return 0;
}

x能读且能被编辑；
y经过const的修饰，只能读，不能进行编辑；
权限被缩小，但是并不影响，故能行。

2.44权限的平移

int main()             
{
	const int x = 1;             
	const int& y = x;             

	int m = 2;             
	int& n = m;             

	return 0;             
}

就像是正常使用一样
当都加const修饰，或者，都不加const修饰，其x与y都是一样的权限，都可以正常使用。

2.45特殊场景

1.场景一

int main()        
{
	const int x = 1;        
	int y = x;        


	return 0;        
}

这里的y并不是引用，并不是权限的放大，而是给y赋值，是x拷贝给y，y的修改，并不会影响x的值。

2.场景二

int main()
{
	int n = 2;
	const int m = 1;
	 //权限的放大
	// p1可以修改 *p1不可以，const修饰是的*p1
	const int* p1 = &m;
	 p1++;
	 //int* p2 = p1;会报错
	const int* p2 = p1;

	 权限的缩小
	int* p3 = &n;
	const int* p4 = p3;
	return 0;
}

指针也有权限的放大和缩小之类的问题，权限的放大会出错，但是权限的缩小是成立的，是没有问题的。