1.缺省参数

缺省参数是 声明或定义函数时 为 函数的参数指定一个缺省值。在调用该函数时， 如果没有指定实参则采用该形参的缺省值， 否则使用指定的实参

void func(int a = 5)
{
	cout << a << endl;

}

int main()
{
	func(); // 5
	func(10); // 10

	return 0;

}

• 关于缺省的一些分类， 做了下面的总结：
  
  
  

有一些老铁， 就会问：为啥半缺省的时候要从左至右传参， 从右至左缺省啊？？

• 首先， 我们要明确一点，缺省是从右至左的， 那我们如果传参的时候也按照同样的顺序进行传参， 如果传参的个数和缺省的个数是一样的， 那么缺省的意义是什么呢？
  
  

下面的代码是缺省函数的一个应用：

typedef struct Stack
{
	int* a;
	int top;
	int size;
	int capacity;
}ST;

void STInit(ST* head, int DEFAULT = 10) 
{
	int* tem = (int*)malloc(sizeof(int*) * DEFAULT);
	if (tem == NULL)
	{
		perror("malloc fail");
		return;
	}

	head->a = tem;
	head->capacity = DEFAULT;

}

int main()
{
	ST st;
	STInit(&st); // 使用10
	STInit(&st, 20); // 使用20

	return 0;

}

在单链表、 栈 、 队列这些线性结构中， 初始化要给多少空间是拿捏不准的，如果给大了， 用户用的少； 如果给小，用户不够用，还要增容（增容是很浪费空间 和 时间的）。所以， 我们想能不能有这样的情况： 先给一个默认值， 如果用户感觉小了， 再给大一点； 如果感觉适中， 就用这个默认值。
刚学的缺省参数就派上了用场， 这样多方便啊。 在C语言中， 可以用 # define MIN 10; （宏）来替代一些作用， 但是他不能像缺省参数这样可以随意改变大小啊？

注意：

1. 缺省参数必须从右至左依次来给， 不能间隔着给
2. 缺省值一般是常量、全局变量（这个一般不推荐）
3. 如果声明和定义分明（声明在.h 文件中， 定义在.cpp 文件中），缺省参数不能在函数定义 和 声明中同时给的（缺省参数是给声明的， 因为在函数的编译环节， 编译器看到的是函数声明，在最后的链接过程，才找到定义）；如果函数的声明和定义是在同一个文件中， 可以给声明，也可以给定义（因为在这个过程中， 函数的编译 和 链接过程是一起进行的）

2.函数重载

中国文化博大精深， 历史源远流长。在我们的日常生活中， 有许多词语一词多义， 单拎出来，不知道是什么意思，要借助上下文来判断该词语的真正含义， 即改词被重载了。

2.1函数重载的概念

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

1. 参数个数不同

int Sub(int a, int b)
{
	cout << "Sub(int a, int b)" << endl;
	return a - b;

}

int Sub(int a)
{
	cout << "Sub(int a)" << endl;
	return a;

}

int main()
{
	Sub(5); // Sub(int a)
	Sub(10, 8); // Sub(int a, int b)

	return 0;
}

2. 类型顺序不同

int Sub(int a, int b)
{
	cout << "Sub(int a, int b)" << endl;
	return a - b;

}

int Sub(int a, double b)
{
	cout << "Sub(int a, double b)" << endl;
	return a;

}

int main()
{
	Sub(5, 1.5); // Sub(int a, double b)
	Sub(10, 8); // Sub(int a, int b)

	return 0;
}

3. 类型不同

int Sub(double a, int b)
{
	cout << "Sub(double a, int b)" << endl;
	return a - b;

}

int Sub(int a, double b)
{
	cout << "Sub(int a, double b)" << endl;
	return a;

}

int main()
{
	Sub(5, 1.5); // Sub(int a, double b)
	Sub(1.5, 8); // Sub(double a, int b)

	return 0;
}

有些老铁看到这里， 忍不住问了： 那我如果函数返回类型不同， 但函数的形参列表相同，构不构成函数重载？？

• 首先， 上面所说的构成函数重载的条件是形参列表不同， 即形参的类型、 形参的个数 或 形参类型的顺序不同；
• 其次， 如果想看原理性的答案， 请移步下面 “函数重载的原理”

2.2函数重载的原理

C++的函数重载，依赖于C++对函数进行了修饰（不同的平台，修饰规则不同），然后才会自动匹配类型/ 自动识别类型。
通过下面的一张图， 使我们对C 和 C++ 的函数调用有个更深刻的理解

来一个面试题来检查一下我们上面的两个内容：

void Add(int a = 0)
{
	cout << "Add(int a = 0)" << endl;
}

void Add()
{
	cout << "Add()" << endl;
}

上面的代码能不能构成重载？
首先， 能构成重载（因为参数的个数不同）
其次， 无参调用时，会存在歧义， 重载不明确

3.auto关键字

3.1类型别名思考（typedef）

随着程序越来越复杂， 程序中用到的类型也越来越复杂， 经常体现在：

1. 类型难于拼写
2. 含义不明确导致容易出错

以后我们要学的迭代器很长、也很容易写错， 我们用atuo（自动匹配类型）就很舒服。 有些聪明的老铁就会反问：我们用 typedef 也不是一样的效果嘛？ 使用 typedef 给类型取别名 确实是可以简化代码， 但是也有些新的问题，见下面的代码：

typedef int* pint;


int main()
{
	const pint p1; // 能否编译成功
	const pint* p2; // 能否编译成功

	return 0;
}

在编程时， 通常要给变量 或 表达式 赋初值， 这就要求在声明变量的时候要清楚地知道表达式的类型， 然而有时候要做到这一点并非是很容易的， 因此C++给 auto 赋予了新的含义。

3.2auto的简介

C++11中， 标准委员会赋予了 auto 全新的含义： auto 不再是 一个存储类型指示符， 而是作为一个全新的类型指示符来指示编译器， auto 声明的变量必须有编译器在编译时期推到而得。简而言之， 在新的C++标准中， 使用 auto 可以由推导变量 或者是表达式的类型。
通过下面的代码， 我们来清楚地看一下：

double Add(int a, double b)
{
	return a + b;

}

int main()
{
	int a;
	auto b = 2.1;
	auto c = 'a';

	cout << typeid(a).name() << endl; // int
	cout << typeid(b).name() << endl; // double
	cout << typeid(c).name() << endl; // char
	cout << typeid(Add).name() << endl; // double __cdecl(int,double)

	return 0;

}

总结：

1. 使用 auto 定义变量的时候必须要对其进行初识化， 在编译阶段， 编译器需要根据初始化来推导 auto 的实际类型
2. auto 并非是一种 “类型” 的声明， 而是一个类型声明时的 “占位符”， 编译器在编译时会将 auto 这个东东 替换成 变量的实际类型

3.3auto的使用规则

1. auto 与指针 和 引用结合起来使用

先让我们来看一下代码：

int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;

	cout << typeid(a).name() << endl; // int * __ptr64
	cout << typeid(b).name() << endl; // int * __ptr64
	cout << typeid(c).name() << endl; // int

	*a = 20;
	*b = 40;
	c = 50;
	cout << a << " " << *a << endl; // 00000030CB8FFA44 50
	cout << b << " " << *b << endl; // 00000030CB8FFA44 50
	cout << &c << " " << c << endl; // 00000030CB8FFA44 50

	return 0;

}

• 如上图结果所知： 用 auto 声明指针类型时， auto 和 auto* 是一样的，没有任何区别。但是 auto 声明引用类型时， 必须要加&。

2. 在同一行定义多个变量

int main()
{
	auto a = 1, b = 2; // 能够编译成功
	auto c = 1, d = 4.0; // 编译失败， c 和 d的初始化的类型是不一样的

	return 0;
}

• 用 auto 在同一行定义多个变量时， 这些变量必须是相同的类型， 只要有变量的类型有不一样的，就会编译错误。
  因为编译器实际上只对第一个类型进行推导（从左至右），然后用推导出来的类型来定义其他变量。

3.4 auto不能推导的场景

1. auto 不能作为函数的参数（肯定是形参啊）

int Sub(auto a); // 会编译错误， auto 不能作为形参参数， 因为编译器不能对 a 的实际类型进行推导

int main()
{
	int a = 0;
	Sub(a);

	return 0;
}

2. auto 不能直接用来声明数组

int main()
{
	int a[] = { 1, 2, 3 };
	auto b[] = { 4, 5, 6 }; // 即使有[]，编译器也不能进行推导

	return 0;
}

3. auto 在实际中最常用的优势用法是C++ 提供的新式for 循环， 还有lambda表达式等进行配合使用

4.基于范围的for循环

这个数组的范围是确定的啊， 为啥会报越界的error啊？？
不理解、不理解！！
祖师爷，来出一个东东来解决一下吧
星光荡开宇宙， 范围for循环闪耀登场

4.1范围for的语法

对于一个有范围的集合而言， 对程序员来说循环的范围是多余的， 有时候还容易犯错误！！因此， 我们的祖师爷就引入了基于范围的for循环。
基本构成： 原本for循环（）内的内容变成 由冒号（：）分成的两部分； （类型 : 有范围的集合）

让我们通过下面的代码来清楚地看一下：

int main()
{
	int arr[] = { 1,2,3,4,5 };
	for (int a : arr)
	{
		cout << a << " ";
	}
	cout << endl; // 1 2 3 4 5

	for (auto a : arr)
	{
		cout << a << " ";
	}
	cout << endl; // 1 2 3 4 5

	for (auto& a : arr)
	{
		a *= 2; // 将每个数都乘2
		cout << a << " ";
	}
	cout << endl; // 2 4 6 8 10

	return 0;

}

总结：

1. auto 和 引用（&）跟 范围for循环 配合使用是非常的香
2. 与普通循环类似， 可以用 continue 来结束本次循环， 也可以用 break 来跳出整个循环

4.2范围for的使用条件

1. for循环迭代的范围必须是确定的

对于数组而言， 就是数组中第一个元素 和 最后一个元素 的范围
对于类而言， 应该提供begin 和 end的范围， begin 和 end 就是循环迭代的范围

void test(int arr[]) // 这个就是错误的， 因为这里arr是一个指针， 导致循环的范围是不确定的
{
	for (auto a : arr)
	{
		cout << a << end;
	}
}

2. 迭代的对象要实现 ++ 和 == 的操作（关于迭代器的问题， 这个以后再讲）

行路难， 行路难， 多歧路， 今安在？
长风破浪会有时， 直挂云帆济沧海。