第八章--函数进阶

内联函数:

在函数声明和函数定义前加上inline

一个简单的计算平方的代码：

#include <iostream>  
using namespace std;  
inline double square(double x)  
{  
    return x * x;  
};  
int main()  
{  
    cout << "HelloWorld" << endl;  
    double a, b;  
    double c = 13.0;  
    a = square(5.0);                //a=25  
    b = square(4.5 + 7.5);      //b=144  
    cout << a << " " << b << "\n";    
    cout << square(c++) << "\n";    //c=169  
    cout << c << "\n";      //c=14  
    cin.get();  
    return 0;  

}

内联函数的使用：函数经常调用，函数体较小，不包含循环之类的

引用变量:

引用变量的主要用途是用作函数的形参

int apple;

int & banana = apple; //banana是apple的引用变量

在这里&不是指针的地址运算符。banana和apple指向相同的值和内存单元

引用变量必须声明是初始化，而不是先声明在赋值

int & banana; //先声明引用变量

banana =  apple; //在赋值。非法的

 

函数模板的局限性：

template <class T>

void f(T a, T b){...}

a = b //如果T为数组，不成立

if(a > b) //如果T为结构，不成立

编写的模板很可能无法处理某些类型

 

函数模板显示具象化

一个结构体：

struct job

{

  char name[40];

  double salary;

  int floor;

}

假设只需交换salary和floor成员,而不交换name成员

#include <iostream>
//函数模板原型
template <typename T>
void Swap(T &a, T &b);
struct job
{
    char name[40];
    double salary;
    int floor;
};
//explicit specialiation 显示具体化
template <> void  Swap<job>(job &j1, job &j2);
void Show(job &j);
int main()
{
    using namespace std;

    cout.precision(2);
    cout.setf(ios::fixed, ios::floatfield);
    int i = 10;


　　 int j = 20;
    cout << i << " " << j << endl;
    Swap(i, j);
    cout << "Now i, j =" << i << "," << j << endl;
    job zhang = {"zhangsan", 55.0, 7};
    job li = {"lisi", 66.0, 6};
    cout << "Before job swapping:\n";
    Show(zhang);
    Show(li);
    Swap(zhang, li);
    cout << "After job swappting:\n";
    Show(zhang);
    Show(li);
    
    cin.get();
}

template <typename T>
void Swap(T &a, T &b)　//交换普通变量
{
    T temp;
    temp = a;
    a = b;
    b = temp;
}
template <> void Swap<job>(job &j1, job &j2)//交换结构体的两个成员变量
{
    double t1;
    int t2;
    t1 = j1.salary;
    j1.salary = j2.salary;
    j2.salary = t1;
    t2 = j1.floor;
    j1.floor = j2.floor;
    j2.floor = t2;
    
}
void Show(job &j)
{
    using namespace std;
    cout << j.name << ":" << j.salary << ":" << j.floor << endl;
    cout << endl;
}

 隐式实例化、现式实例化(explicit instantiation)、显式具体化(explicit specialization)

显式实例化的声明：

template void Swap<int>(int, int);

Swap()模板将生成一个使用int类型的实例

显式具体化的声明：

template <> void Swap<int>(int &, int &);

template <> void Swap(int &, int &);

上面两行等价

 

template <class T>

void Swap(T &, T &);//模板原型

template <> void Swap<job>(char &, char &);//显示具体化

int main(void)

{

template void Swap<char>(char &, char &);//显式实例化

short a, b;

Swap(a, b);//隐式模板实例化

job n, m;

Swap(n, m);//显式模板具体化

char g, h;

Swap(g, h);//显式模板实例化

}