内联函数，引用变量，按引用传递参数，默认参数，函数重载，函数模板，函数模板具体化,decltype

要想函数成为内联函数，必须在函数声明或者函数原型前加上inline, inline是建议，不是强制，编译环境会根据是否有必要来决定是否使用inline。inline即是把代码复制到调用点，这样就可以不用保护“现场”，适用于比较短的代码。

引用变量：int a, int &b=a则b是a的引用，a和b指向相同的值和内存单元。和指针的主要差别是必须在声明引用时将其初始化，而不能像指针那样，先声明，再赋值。将引用用作函数参数等效于按地址传递。

右值引用：右值引用可以引用表达式，常量；左值引用只能引用变量。如 void show(int &&n)，show(5+3)。

默认参数：

int harpo(int n, int m = 4, int j = 5);//要从右向左添加默认值
int beeps;
beeps = harpo(2);//等价于harpo(2,4,5)
beeps = harpo(1, 8);//等价于harpo(1,8,5)
beeps = harpo(8, 7, 6);//未使用默认值
beeps = harpo(3, ,4);//错误，不能跳过任何参数

函数重载：函数的特征标与参数的数目，类型，排列顺序有关。若函数名相同而特征标不同即为函数的重载，例如：

void print(int a, int b);
void print(int a, double b);

不同返回值但函数名和特征标相同的函数是互斥的。

函数模板：

#include<iostream>
using namespace std;
template<typename google>
void swop(google &a, google &b)
{
google temp;
temp = a;
a = b;
b = temp;
}
int main()
{
int a, b;
double c, d;
swop(a, b);//google被自动替换成int
swop(c, d);//google被自动替换成double
}

template<typename t1,typenamet2>也是可以的。

重载的函数模板：

template<typename google>
void swop(google a, google b);
template<typename google>
void swop(google a, google b, google c);

显式具体化：

#include<iostream>
using namespace std;
struct job
{
char name[40];
double salary;
int floor;
};
template<typename T>//函数模板
void swop(T&, T&);
template<>void swop<job>(job&, job&);//显式具体化
int main()
{
double u, v;
swop(u, v);//调用模板
job a, b;
swop(a, b);//调用显式具体化
}如果有多个原型，编译器在选择原型时，非模板版本优先于显式具体化，显式具体化优先于模板（更具体的函数优先原则）。显式具体化的格式也可以为template<>void swop(job&,job&)。
显式实例化：格式为template void swop<int>(int,int)；编译器看到上述声明后，将调用swop模板生成一个int类型的实例，即使用swop模板生成int类型的函数定义。具体化和实例化的不同点是：具体化是自己写的函数定义，实例化是编译器根据函数模板生成的函数定义。

decltype：decltype(x)y, 使y和x的类型相同。例如decltype(x+y)xpy=x+y，在不确定x和y类型时使用。

后置返回类型：当返回值由传入参数决定时使用

template<typename t1,typename t2>
auto gt(t1 x, t2 y)->decltype(x + y)
{
return x + y;
}