inline double fun(int a)
{
   return a*a;
}

int main()
{
   int i=2;
   cout<<fun(i)<<endl;
   return 0;
}
//若使用内联函数
cout<<fun(i)<<endl;就会变成cout<<i*i<<endl;

2.如何使用内联函数

在函数前面加上inline。

在类的成员函数可以直接在类的内部给出函数体，不用加inline就可以成为内联函数。

内联函数的限制

函数内不能有循环或者switch结构
不能有任何静态数据和数组的声明
不能是递归函数

这里注意一点，inline函数不区分声明和定义。

并不是所有函数都可以成为内联函数，如果一个函数含有循环 switch等语句编译器将不会将其解释为内联函数，即使你使用了inline。就是说我们只有建议内联的权利，是否真的实现内联还要由编译器决定

3.内联函数与宏

#define square(x) x*x

a= square(5);  会被解释成 5*5 是对的
b= square(1+2); 会被解释成 1+2*1+2 出错了
c= square(b++); 会被解释成 b++*b++

使用宏可能会出错，使用内联函数则不会。

其次，内联函数还有一个优点，它有返回类型，也就是说，编译器可以通过检查返回类型来检查是否出错，而宏定义没有返回类型。

4.引用变量

语法：

int a=1;

int & i=a;

引用只能指向一个变量，一旦指向后就不可更改。

可以通过改变i来改变a，其实引用是用指针实现的，int &i = a可以理解为，int const *i=&a;一个指向int变量的常指针，C++的设计者，简化了这些符号，使用了&。

#include <iostream>
#include<exception>
using namespace std;


int main()
{
    int a = 3;
    int b = 4;
    int & c = a;
    cout << "c="<<c << endl;
    c = b;
    cout << "step1:" << endl;
    cout << "c="<<c << endl;
    cout << "输出c等于4，难道改变了引用的指向,使c指向了b!?" << endl;

    cout << "step2:" << endl;
    b = 5;
    cout << "c="<<c << endl;
    cout << "改变b的值，c并未发生变化，说明c没有指向b" << endl;

    cout << "step3:" << endl;
    cout << "a=" << a << endl;
    cout << "引用就是给变量取别名，c引用a说明c就是a的别名，c=b相当于a=b，其实就是对a进行了赋值操作,所以a的值发生了变化" << endl;

    cout << "step4:" << endl;
    a = 6;
    cout << "c="<<c << endl;
    cout << "改变a的值，c发生变化，说明c任然是指向a" << endl;

    cout << endl<<"结论：不能改变引用的指向"<<endl;

    return 0;
}

5.将引用作为函数参数

函数参数如果不是指针的话，程序会为其创建一个副本，将副本传过去，这就意味着需要花费时间和内存，使用指针可以优化这个过程，直接传一个地址过去，让函数直接访问这个地址里的数据，减少了时间开销。上面提到引用时常指针，因此用引用也可以起到减少时间开销的作用。

函数参数为引用的话，不能传一个表达式过去例如 fun（x +3)

如果实参与引用参数不匹配但可以转换成正确的类型或者实参类型正确，但不是左值，C++会生成临时变量。

仅当参数为const引用时，C++才允许这样做。

#include<iostream>
using namespace std;
void print(const int &a)
{
  cout<<a<<endl;
}

int main()
{
  long a,b;
  a=1,b=2;
  print(a+3);
  return 0;
}

个人认为，const是用来规范的，意思就是你类型不对，程序会创建一个正确类型的副本，并使形参引用他，那么即使你修改了形参，也不会改变主函数里的数据。所以一般这种情况，加一个const，相当于告诉编译器让它来帮忙检查程序员是否犯了这个错误。

当函数的返回类型为引用时候，不要返回一个临时变量的引用

6.关于对象的引用

对于基类和派生类来说，基类的引用可以指向派生类的引用，而且无需进行类型转换。

7.使用引用的原因

（1）程序员能够修改调用函数里的数据对象

（2）通过传递引用而不是整个数据对象，可以提高程序的运行速度。

8.引用、指针、值的使用情况

数据对象比较小，采用按值传递。

对象是数组或者结构，采用指针。

类对象，采用引用。

9.默认参数

C++允许函数使用默认参数，例如fun（int a,int b=0）;

这样意味着你可以这样调用fun函数：fun（1），b被默认初始化为0了，如果你不想使用默认的b值，则可以这样fun（1，2）；

注意事项：必须从右往左添加默认值，例如 fun(int a,int b=1,int c=2)

对于 fun2(int a=1,int b=2,int c=3)

不允许这样调用 fun2(1,,4);

10.函数重载

函数重载的关键在于函数的参数列表。也称为函数的特征标，特征标包含函数的参数数目，类型，参数的排列顺序。

只有当函数的特征标不同时候，才可以实现函数重载

类型引用和类型本身视为同一个特征标

就是说print(int &i)和print(int i)无法重载，编译器无法决定使用哪一个。

函数的特征标相同但函数的返回类型不同的函数也无法重载

如long fun（int i）和 int fun(int i)

函数重载的实现：C++编译器执行神奇的操作——名称修饰，会根据函数原型中指定的形参类型对每个函数名进行加密，也就是说即使函数名相同，如果函数特征标不同的话，编译器编译出来的函数们，它们的名称是不同的，这样在调用的时候，程序会根据参数类型去找正确的函数。

注意：一个函数既不能作为重载函数，又作为有默认参数的函数

因为，如果调用的时候少写一实参，系统无法判断是利用重载函数还是默认参数的函数

11.函数模板

什么时候使用模板？

如果需要多个将同一种算法应用于不同种类型的函数，请使用模板

对于某些功能相同的函数，如果他们的参数个数相同，可以使用模板

语法：template

函数类型函数名函数参数

例如：

template

void swap(T &a,T&b)

{

T t=a;

a=b;

b=t;

}

程序执行时候会根据函数模板和给定参数类型去生成一个给定参数类型的函数。

显示具体化

当编译器找到与函数调用匹配的具体化定义时，将使用该定义，而不再寻找模板。

什么时候用显示具体化呢，举个例子，当我们在使用上述swap函数模板交换结构体的时候，我们希望几交换结构体中的某个数据对象，而不交换其他数据对象，这时候就可以使用显示具体化。

struct job
{
    string name;
    double salary;
    int floor;
};

template<>
void Swap<job>(job &j1,job &j2)//只交换薪水
{
    double t1;
    t1=j1.salary;
    j1.salary=j2.salary;
    j2.salary=t1;
}

还有一个叫显示实例化的东西，就是说你告诉编译器，让编译器提前生成一个类型的函数

如 template void swap(int,int );这是个声明

所谓隐式实例化就是程序根据参数类型来生成函数。

显示实例化隐式实例化显示具体化统称为具体化

编译器选择使用哪一个函数版本

第一步：创建候选函数列表。其中包含与被调函数名称相同的函数和模板函数

第二步：使用候选函数列表创建可执行函数。

第三步：确定是否有最佳的可行函数。

从最佳到最差的顺序为：

1.完全匹配

2.提升转换（如 shorts 转换为 int ，float转换为double）

3.标准转换（如char 转换为int，long转换为double）