函数重载

C++支持同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数不同，也可使是参数类型ing不同。这样C++函数调用就表现出了多态行为，使用更加灵活。

//1.参数类型不同
int Add(int left, int right)
{
 cout << "int Add(int left, int right)" << endl;
 return left + right;
}

double Add(double left, double right)
{
 cout << "double Add(double left, double right)" << endl;
 return left + right;
}

// 2、参数个数不同 

void f()
{
 cout << "f()" << endl;
}
void f(int a)
{
 cout << "f(int a)" << endl;
}

// 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;
}

引用

引用的概念和定义

类型 & 引⽤别名 = 引⽤对象；

int main()
{
	//这里r就是a的别名
	int a = 10;
	int& r = a;
	//当然我们也可以给r取别名
	int& l = r;

	//取地址我们可以看到结果是胸痛的
	cout << &a << endl;
	cout << &r << endl;
	cout << &al<< endl;

	return 0;

}

引用的特性

1.引用在定义是必须初始化

2.一个变量可以有多个引用

3.引用一旦引用一个实体，就不能引用其他实体

#include<iostream>
using namespace std;
int main()
{
 int a = 10;
 
 // 编译报错：“ra”: 必须初始化引⽤ 
 //int& ra;
 int& b = a;
 int c = 20;
 // 这⾥并⾮让b引⽤c，因为C++引⽤不能改变指向， 
 // 这⾥是⼀个赋值 
 b = c;
 cout << &a << endl;
 cout << &b << endl;
 cout << &c << endl;
 return 0;
}

引用的使用

1.引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象的同时改变被引用对象。（在值传递中会生成临时拷贝，临时拷贝过大的话会降低运行效率）

2.引用传参和指针传参功能是类似的，引用传参相对更方便一些

3.引用和指针在实践中相辅相成，功能会有重叠，但是各有特点，不想不可替代

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

void Swap(int* ra, int* rb)
{
	int tmp = *ra;
	*ra = *rb;
	*rb = tmp;
}

这里的&符号的作用就是给参数起别名，这样对别名进行修改就是对对象本身就行修改，跟指针是相同的。

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST& rs, int n = 4)
{
	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
	rs.top = 0;

 rs.capacity = n;
}
// 栈顶 
void STPush(ST& rs, STDataType x)
{
	assert(ps);
	// 满了， 扩容 
	if (rs.top == rs.capacity)
	{
		printf("扩容\n");
		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
		STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *
			sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		rs.a = tmp;
		rs.capacity = newcapacity;
	}
	rs.a[rs.top] = x;
	rs.top++;
}
// int STTop(ST& rs)
int& STTop(ST& rs)
{
	assert(rs.top > 0);
	return rs.a[rs.top];
}
int main()
{
	// 调⽤全局的 
	ST st1;
	STInit(st1);
	STPush(st1, 1);
	STPush(st1, 2);
	cout << STTop(st1) << endl;
	STTop(st1) += 10;
	cout << STTop(st1) << endl;
	return 0;
}

 这里也是取别名来代替了指针传参。

但是引用传参和指针传参在某些地方是不同的，指针的指向对象是可以更改的，但是引用的对象不可以更改的。

const引用

1.可以引用一个const对象，但是必须用const引用。const引用也可以引用普通的对象，因为对象的访问权限在引用过程中可以缩小，但是不可以放大。

2.需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产⽣临时对象存储中间值，也就是时，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性，所以这⾥ 就触发了权限放⼤，必须要⽤常引⽤才可以。

int main()
{
	const int a = 10;

	// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &” 
    // 这⾥的引⽤是对a访问权限的放⼤ ,本身a是个常量，但是r作为a的别名却不具有常性，可以更改，这里的权限就被放大了
	int& ra = a;
	//这样才是合法的引用
	const int& ra = a;


	//这里的引用是合法的，是对权限的缩小
	int b = 20;
	const int& rb = b;

	nt a = 10;
	const int& ra = 30;

	// 编译报错: “初始化”: ⽆法从“int”转换为“int &” 
	// int& rb = a * 3;
	const int& rb = a * 3;
	double d = 12.34;
	// 编译报错：“初始化”: ⽆法从“double”转换为“int &” 
	// int& rd = d;
	const int& rd = d;

	return 0;
}

指针和引用的关系

1.语法概念上引⽤是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间

2.引⽤在定义时必须初始化，指针建议初始化，但是语法上不是必须的

3.引⽤在初始化时引⽤⼀个对象后，就不能再引⽤可以直接访问指向对象，指针需要解引⽤才是访问

4.指向对象。引⽤其他对象；⽽指针可以在不断地改变指向对象

5.sizeof中含义不同，引⽤结果为引⽤类型的⼤⼩，但指针始终是地址空间所占字节个数(32位平台下 占4个字节，64位下是8byte)

6.指针很容易出现空指针和野指针的问题，引⽤很少出现，引⽤使⽤起来相对更安全⼀些

inline

⽤inline修饰的函数叫做内联函数，编译时C++编译器会在调⽤的地⽅展开内联函数，这样调⽤内联 函数就需要建⽴栈帧了，就可以提⾼效率

inline对于编译器⽽⾔只是⼀个建议，也就是说，你加了inline编译器也可以选择在调⽤的地⽅不展 开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适⽤于频繁 调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略

C语⾔实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不⽅便调 试，C++设计了inline⽬的就是替代C的宏函数

我们需要知道的是 宏函数的作用主要是替换，所以inline修饰的主要目的也是替换。

inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地 址，链接时会出现报错

nullptr

#include<iostream>
using namespace std;
void f(int x)
{
	cout << "f(int x)" << endl;
}
void f(int* ptr)
{
	cout << "f(int* ptr)" << endl;
}
int main()
{
	f(0);
	// 本想通过f(NULL)调⽤指针版本的f(int*)函数，但是由于NULL被定义成0，调⽤了f(int 
	x)，因此与程序的初衷相悖。
	f(NULL);
	f((int*)NULL);
	// 编译报错：error C2665: “f”: 2 个重载中没有⼀个可以转换所有参数类型 
	// f((void*)NULL);

	f(nullptr);
	return 0;
}