将模板应用于多文件编程

时间：01-05来源：作者：点击数：570

在将函数应用于多文件编程时，我们通常是将函数定义放在源文件（.cpp文件）中，将函数声明放在头文件（.h文件）中，使用函数时引入（#include命令）对应的头文件即可。

编译是针对单个源文件的，只要有函数声明，编译器就能知道函数调用是否正确；而将函数调用和函数定义对应起来的过程，可以延迟到链接时期。正是有了链接器的存在，函数声明和函数定义的分离才得以实现。

将类应用于多文件编程也是类似的道理，我们可以将类的声明和类的实现分别放到头文件和源文件中。类的声明已经包含了所有成员变量的定义和所有成员函数的声明（也可以是 inline 形式的定义），这样就知道如何创建对象了，也知道如何调用成员函数了，只是还不能将函数调用与函数实现对应起来，但是这又有什么关系呢，反正链接器可以帮助我们完成这项工作。

总起来说，不管是函数还是类，声明和定义（实现）的分离其实是一回事，都是将函数定义放到其他文件中，最终要解决的问题也只有一个，就是把函数调用和函数定义对应起来（找到函数定义的地址，并填充到函数调用处），而保证完成这项工作的就是链接器。

基于传统的编程思维，初学者往往也会将模板（函数模板和类模板）的声明和定义分散到不同的文件中，以期达到「模块化编程」的目的。但事实证明这种做法是不对的，程序员惯用的做法是将模板的声明和定义都放到头文件中。

模板并不是真正的函数或类，它仅仅是用来生成函数或类的一张“图纸”，在这个生成过程中有三点需要明确：

模板的实例化是按需进行的，用到哪个类型就生成针对哪个类型的函数或类，不会提前生成过多的代码；
模板的实例化是由编译器完成的，而不是由链接器完成的；
在实例化过程中需要知道模板的所有细节，包含声明和定义。

将函数模板的声明和定义分散到不同的文件

为了更加深入地说明问题，现在有一个反面教材，它将函数模板的声明和实现分别放到了头文件和源文件。

func.cpp 源码：

//交换两个数的值
template<typename T> void Swap(T &a, T &b){
    T temp = a;
    a = b;
    b = temp;
}
//冒泡排序算法
void bubble_sort(int arr[], int n){
    for(int i=0; i<n-1; i++){
        bool isSorted = true;
        for(int j=0; j<n-1-i; j++){
            if(arr[j] > arr[j+1]){
                isSorted = false;
                Swap(arr[j], arr[j+1]);  //调用Swap()函数
            }
        }
        if(isSorted) break;
    }
}

func.h 源码：

#ifndef _FUNC_H
#define _FUNC_H
template<typename T> void Swap(T &a, T &b);
void bubble_sort(int arr[], int n);
#endif

main.cpp 源码

#include <iostream>
#include "func.h"
using namespace std;
int main(){
    int n1 = 10, n2 = 20;
    Swap(n1, n2);
   
    double f1 = 23.8, f2 = 92.6;
    Swap(f1, f2);
    return 0;
}

该工程包含了两个源文件和一个头文件，func.cpp中定义了两个函数，func.h中对函数进行了声明，main.cpp中对函数进行了调用，这是典型的将函数的声明和实现分离的编程模式。

运行上面的程序，会产生一个链接错误，意思是无法找到void Swap<double>(double &, double &)这个函数。主函数 main() 中共调用了两个版本的 Swap() 函数，它们的原型分别是：

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

为什么针对 int 的版本能够找到定义，而针对 double 的版本就找不到呢？

我们先来说针对 double 的版本为什么找不到定义。当编译器编译main.cpp时，发现使用到了 double 版本的 Swap() 函数，于是尝试生成一个 double 版本的实例，但是由于只有声明没有定义，所以生成失败。不过这个时候编译器不会报错，而是对该函数的调用做一个记录，希望等到链接程序时在其他目标文件（.obj 文件或 .o 文件）中找到该函数的定义。很明显，本例需要到func.obj中寻找。但是遗憾的是，func.cpp中没有调用 double 版本的 Swap() 函数，编译器不会生成 double 版本的实例，所以链接器最终也找不到 double 版本的函数定义，只能抛出一个链接错误，让程序员修改代码。

那么，针对 int 的版本为什么能够找到定义呢？请读者注意bubble_sort()函数，该函数用来对数组元素进行排序，在排序过程中需要频繁的交换两个元素的值，所以调用了 Swap() 函数，这样做的结果是：编译生成的func.obj中会有一个 int 版本的 Swap() 函数定义。编译器在编译main.cpp时虽然找不到 int 版本的实例，但是等到链接程序时，链接器在func.obj中找到了，所以针对 int 版本的调用就不会出错。

将类模板的声明和实现分散到不同的文件

我们再看一个类模板的反面教材，它将类模板的声明和实现分别放到了头文件和源文件。

point.h 源码：

#ifndef _POINT_H
#define _POINT_H
template<class T1, class T2>
class Point{
public:
    Point(T1 x, T2 y): m_x(x), m_y(y){ }
public:
    T1 getX() const{ return m_x; }
    void setX(T1 x){ m_x = x; }
    T2 getY() const{ return m_y; };
    void setY(T2 y){ m_y = y; };
    void display() const;
private:
    T1 m_x;
    T2 m_y;
};
#endif

point.cpp 源码：

#include <iostream>
#include "point.h"
using namespace std;
template<class T1, class T2>
void Point<T1, T2>::display() const{
    cout<<"x="<<m_x<<", y="<<m_y<<endl;
}

main.cpp 源码：

#include <iostream>
#include "point.h"
using namespace std;
int main(){
    Point<int, int> p1(10, 20);
    p1.setX(40);
    p1.setY(50);
    cout<<"x="<<p1.getX()<<", y="<<p1.getY()<<endl;
    Point<char*, char*> p2("东经180度", "北纬210度");
    p2.display();
    return 0;
}

该工程包含了两个源文件和一个头文件，point.h中声明了类模板，point.cpp中对类模板进行了实现，main.cpp中通过类模板创建了对象，并调用了成员函数，这是典型的将类的声明和实现分离的编程模式。

运行上面的程序，会产生一个链接错误，意思是无法通过 p2 调用Point<char*, char*>::display() const这个函数。

类模板声明位于point.h中，它包含了所有成员变量的定义以及构造函数、get 函数、set 函数的定义，这些信息足够创建出一个完整的对象了，并且可以通过对象调用 get 函数和 set 函数，所以main.cpp的前 11 行代码都不会报错。而第 12 行代码调用了 display() 函数，该函数的定义位于point.cpp文件中，并且point.cpp中也没有生成对应的实例，所以会在链接期间抛出错误。