C++：缺省参数|函数重载|引用|const引用

欢迎来到Harper·Lee的学习笔记！

博主主页传送门：Harper·Lee的博客主页

想要一起进步的uu可以来后台找我哦！

一、缺省参数

1.1 缺省参数的定义

缺省参数：是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采⽤该形参的缺省值，否则使用指定的实参。（有些地方把缺省参数叫做默认参数）

#include 
using namespace std;
void Func(int a = 0)//行参的后面赋一个常量值或者全局变量值，指定参数值
{
	cout 
	Func(); // 没有传参时，使⽤参数的默认值
	Func(10); // 传参时，使⽤指定的实参
	return 0;
}

	cout 
	Func1();//不传参数，10，20，30
	Func1(1);//传一个参数，1，20，30
	Func1(1, 2, 3);//1，2，3
    //Func1( ,1, );这种形式不可以，因为是本贾尼规定的
	return 0;
}

	cout 
    //Func2();//不传参数会报错
	Func2(100);//
	Func2(100, 200);
    Func2(100,200,300);
	return 0;
}

	cout 
    Func2(100, ,300);//error
    return 0;
}
}//error
//如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。
//test.h
void Func2(int a = 10);//声明中赋缺省值
// test.cpp
void Func2()//定义中没有赋缺省值
{}//right

	return a + b;
}
double Add(double a, double b)
{
	return a + b;
}
int main()
{
	cout 
	cout 
	cout 
	f();//调用的是没有参数的f函数
	f(1);//调用的是有参数f函数
	return 0;
}

	cout 
	cout 
	f1(1, 2.0);
	f1(1.0, 2);
	return 0;
}

	cout 
	cout 
	f3();//error函数调用看的是行参，与缺省参数没有关系！因此发生歧义！！！
	f3(2);//给了参数就明确说明是要调用第二个函数
	return 0;
}
}
int fxx()
{
	return 0;
}

	int a = 0;
	int& b = a;//引⽤：b是a的别名
	int& c = b;//也可以给别名b取别名，c相当于还是a的别名
	++c;//就是++b，也就是++a
	cout 
	int a = 1;
	int& b = a;//引用b取别名，是a的别名
	int d = 20;
	b = d;//这是一个赋值，因为不能改变指向
	printf("b = %d\n", b);
	cout 
	int m = 20;
	x = m;//x被改变，实体a也被改变（引用对象改变了，被引用对象也改变了）
	cout 
    int m = 20;
    *x = m;
 	cout 
	int a = 2;
	Func(a);
    //Func1(&a);
	return 0;
}

	int tmp = *a;
	*a = *b;
	*b = tmp;
}
//C++中引用形式的Swap函数
void Swap2(int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
}
int main()
{
	int x = 2, y = 4;
	Swap1(&x, &y);..是用来指针
	cout 
	int a = 0;
	return a;//返回后，函数栈桢被销毁，返回引用，相当于返回一个野指针
}

	int a = 0;
	int* p = &a;
	*p = 1;//指针需要解引用才能访问对象
	int& ra = a; 
	ra = 2;//引用可以直接访问对象
	return 0;
}

    int a = 0; 
    return a;
}//返回一个类似野指针的东西，相当于是空引用

	const int a = 10;
	int& ra = a;        //error，权限放大
	const int b = 20;
	const int& rb = b;  //right,权限平移
	int c = 30;
	const int& rc = c;  //right,权限缩小
	++c;                //right
	++rc;               //error，c和rc是同一个地址不同的权限
	const int& rd = 40; //right,const引用可以给常量取别名
	int& re = (a + b);  //error，C++规定临时对象具有常性，这里，权限放大，const修饰即可
	const int& rf = (a + b);//right
    int rg = (a + b);//拷贝，不存在权限放大
    //a+b被存放在临时对象中，对临时对象引用取别名需要const修饰
    
	return 0;
}

    int a = 10;
    int b = 20;
    const int& rf = (a + b);//right,
    //a+b表达式的结果被存放在临时对象中，rf引用的对象是这个临时对象
    //但是临时对象具有常性，因此需要const修饰
    
    return 0;
}

	double d = 12.34;
	int i = d;//这里是通过了隐式类型转换，中间产生一个int临时对象存储d，i=12
	int& ri = d;          //error
	const int& rii = d;   //right，rii引用d，实际是引用的d的临时对象i
	return 0;
}