C++函数重载/默认值/函数模板

C++函数修饰符

• const 修饰成员函数，该函数不能修改类的任意数据成员，也不能调用类的其他成员函数，除了那些也被声明为const的函数。
• constexpr，C++11特有的，编译器将把从函数的返回值十位编译时的常量。此函数必须正好有一个return语句。
• explicit，只修饰成员函数（具体来说是构造函数），使构造函数不提供隐式转换的功能。
• final，C++特有的，只修饰成员函数，适用于虚函数，防止该函数被派生类重载（该关键字通常运用于派生类内的虚函数，此派生类可能有自己的派生类，final的要点是防止对函数有进一步的重载）。
• inline，内联函数，修饰任意函数，此关键字是一个建议，他告诉编译器应该把此函数实现为内联函数。最先进的现代编译器是优化的编译器，它们自己决定要内联的对象，所以一度被认为很重要的关键字，现在只是一个对编译器的建议。
  特点：以空间换时间，提高函数调用的效率。C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。对于短函数进行内联是非常有效的，这消除了函数调用的开销。递归函数不能被内联。
• override，C++11特有的，只修饰成员函数，该关键字指定该函数重载基类中声明的一个函数。
• static，当其应用于全局函数时，可使函数只在当前源文件中可见。在默认情况下，C++中的函数名具有外部链接，使每个模块用相同的名称声明的一个函数必须指向相同的函数（它必须只在一个模块中被定义）。当用于成员函数时，该函数变成类的一个静态函数，使得它不能访问类的其它 成员，除非它们也被声明为静态。通过 类名：：函数 语法来调用。

函数重载（函数多态）

C++允许使用相同的名称定义多个函数，只要它们根据参数列表区分。重载函数可以有不同的返回类型。但是参数列表必须不同。

int test(int a）;
double test(double a);
double test(int a);//错误，参数列表相同

带有默认值的参数

如果一个函数有多个默认参数，但只传递了其中一些，编译器会按照顺序匹配它们

void test（int a = 0; int b = 10, c = 20）;
//如果一个函数有多个默认参数，但只传递了其中一些，编译器会按照顺序匹配它们
test();//a = 0,b = 10, c = 20
test(100);//a = 100,b = 10, c = 20
test(100,200);//a = 100,b = 200, c = 20

可变长参数列表

在C++中可以编写采用任意数量的参数的函数（如C语言中的printf()函数）。

lambda匿名函数

内联函数（inline）

普通函数调用过程：程序将在函数调用后立即存储该指令的内存地址，并将函数参数复制到堆栈中，跳到函数起点的内存单位，执行函数代码（也许还需将返回值放入寄存器中），然后跳回地址被保存的指令处（这与阅读文章时停下来看脚注，并在看完脚注后再返回以前阅读的地方类似），来回跳跃并记录跳跃位置需要一定的开销。
内联函数的核心就是：以空间换时间。
编译器将使用相应的函数代码替换函数调用。也就是说在函数调用的地方直接把函数的代码复制过来使用，这样就无需跳来跳去。内联函数的运行速度比常规函数块，但代价是需要占用更多的内存。如果程序在十个地方调用一个函数，则该程序将包含十个该函数代码的副本。
有选择地使用：

• 如果函数执行的时间比函数调用的时间长，则节省的时间只占一小部分。
• 需要从函数代码所占内存，函数在程序中的调用次数（在不同地方），函数运行时间来考虑。
• 内联函数不能递归。
  必须在函数声明和定义前加上inline

函数模板

使用泛型来定义函数，例如要交换两个变量的值，他们所使用的算法是一样的，但是变量类型不一样，这时可以使用模板。一套代码，多类型复用。

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
//函数模板原型
template <typename T>//或者class T
void Swap(T &a, T &b);

//模板函数重载
template <typename T>//或者class T
void Swap(T &a, T &b,int n);

int main(void) {

	using namespace std;
	int i = 10, j = 20;
	cout << "i = "<< i << endl;
	cout << "j = " << j << endl;

	Swap(i, j,66);
	cout << "after swaping:" << endl;
	cout << "i = " << i << endl;
	cout << "j = " << j << endl;

	double x = 9.9, y = 2.2;
	Swap(x, y);
	cout << "after swaping:" << endl;
	cout << "x = " << x << endl;
	cout << "y = " << y << endl;
	char a = 'a', b = 'b';
	Swap(a, b);
	cout << "after swaping:" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	return 0;
}

//模板函数定义
template <typename T>
void Swap(T &a, T &b) {
	T temp;
	temp = a;
	a = b;
	b = temp;
}
template <typename T>
void Swap(T &a, T &b, int n) {
	T temp;
	temp = a;
	a = b;
	b = temp;
	cout << "函数重载"<<n << endl;
}
//结果：
/*
i = 10
j = 20
函数重载66
after swaping:
i = 20
j = 10
after swaping:
x = 2.2
y = 9.9
after swaping:
a = b
b = a
*/

模板函数的重载

和常规函数一样，只要参数列表必须不同