将 C++ 模板应用于多文件编程

Posted on

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

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

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

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

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

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

  • 模板的实例化是按需进行的，用到哪个类型就生成针对哪个类型的函数或类，不会提前生成过多的代码

  • 模板的实例化是由编译器完成的，而不是由链接器完成的

  • 在实例化过程中需要知道模板的所有细节，包含声明和定义（只有一个声明是不够的，可能会在链接阶段才发现错误）

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

func.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 交换两个数的值
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

1
2
3
4
5
6
7
#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

1
2
3
4
5
6
7
8
9
10
11
12
#include "func.h"

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 中对函数进行了调用，这是典型的将函数的声明和实现分离的编程模式。

编译一下：

1
gcc func.cpp main.cpp

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

1
2
void Swap<int>(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() 函数中调用了 int 版本的 Swap，这样做的结果是：编译生成的 func.obj 中会有一个 int 版本的 Swap() 函数定义。编译器在编译 main.cpp 时虽然找不到 int 版本的实例，但是等到链接程序时，连接器在 func.obj 中找到了，所以针对 int 版本的调用就不会出错。

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

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

point.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#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

1
2
3
4
5
6
7
8
#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#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 中也没有生成对应的实例，所以会在链接期间抛出错误。

总结

通过上面两个反面教材可以总结出，不能将模板的声明和定义分散到多个文件中的根本原因是：模板的实例化是由编译器完成的，而不是由链接器完成的，这可能会导致在链接期间找不到对应的模板实例。