详解C++函数模板与分离编译模式

下面对C++函数模板与分离编译模式进行详细解析。

1. C++函数模板

C++函数模板是一种可以根据具体的类型生成函数的模板，它可以实现对函数的类型与参数的自适应，从而减少了代码的冗余。C++函数模板的语法如下所示：

template<typename T>
void print(T t) {
    cout << t << endl;
}

上述代码中，template<typename T>指定了该函数为模板函数，typename T表示该函数的类型参数为T，void print(T t)表示该函数具有一个参数名为t，其类型为T，函数实现为输出t所代表的值。使用时可调用该函数并指定类型参数，如下所示：

print<int>(1);   // 输出 1
print<string>("hello"); // 输出 hello

2. 分离编译模式

对于较大的项目，通常会采用多文件的编写方式，在一个文件中定义函数或类型，而在另一个文件中进行函数的调用或类型的使用。分离编译模式就是这样一种模式，它将函数的定义和声明分离出来，通过#include语句进行引用，最终在编译时进行组合。

以函数的例子来说明，比如我们在项目中需要定义一个函数进行字符串的逆序，可定义reverse_string.h头文件，以及reverse_string.cpp源文件，分别包含函数的声明和实现。其中，reverse_string.h定义如下：

#ifndef REVERSE_STRING_H
#define REVERSE_STRING_H

#include <string>

using namespace std;

string reverse_string(string s);

#endif

表示防止重复定义头文件内容，#include<string>是为了使用string类，string reverse_string(string s)是声明函数名和参数string类型的字符串s，这里只是声明，没有实现函数体。而reverse_string.cpp则包含该函数的实现如下所示：

#include "reverse_string.h"

string reverse_string(string s) {
    int n = s.length();
    for (int i = 0; i < n / 2; i++) {
        char temp = s[i];
        s[i] = s[n - i - 1];
        s[n - i - 1] = temp;
    }
    return s;
}

当需要调用该函数时，只需要在调用文件中引入该头文件即可，如下所示：

#include "reverse_string.h"

int main() {
    string s = "hello";
    cout << reverse_string(s) << endl;
    return 0;
}

最后，在编译时需要进行组合，具体步骤可参考以下示例。

示例1：实现变长参数的加法函数模板

使用变长参数和函数模板实现计算多个参数的加法和，具体代码如下：

#include <iostream>
#include <cstdarg>

using namespace std;

template<typename T>
T add(int count, ...) {
    T sum = 0;
    va_list args;      // 申明va_list类型的变量args
    va_start(args, count); // 初始化args指向函数参数列表
    for (int i = 0; i < count; i++) {
        T value = va_arg(args, T); // 依次返回args指向参数列表中指定类型的值
        sum += value;
    }
    va_end(args);    // 将args置为null
    return sum;
}

int main() {
    int res1 = add<int>(3, 1, 2, 3);
    cout << "res1 = " << res1 << endl;   // 输出 res1 = 6
    double res2 = add<double>(4, 1.2, 2.3, 3.4, 4.5);
    cout << "res2 = " << res2 << endl;   // 输出 res2 = 11.4
    return 0;
}

该代码使用va_start()和va_arg()等函数来获取多个参数的值，并对其求和，返回结果。使用时只需要指定类型参数即可。

示例2：在线性表的模板设计中分离编译

对于使用模板类来实现线性表的代码，它的头文件和cpp文件也需要分别进行实现。具体代码如下：

// linear_list.h
#ifndef LINEAR_LIST_H
#define LINEAR_LIST_H

template<typename T>
class LinearList {
public:
    virtual void push_back(T x) = 0;
    virtual T operator[](int i) = 0;
};

#endif

表示申明一个LinearList虚基类，使用纯虚函数实现添加元素和通过下标读取元素，实现类需要继承并完善接口。

// array_list.h
#include "linear_list.h"

template<typename T>
class ArrayList : public LinearList<T> {
public:
    ArrayList(int capacity) {
        if (capacity <= 0) {
            throw "capacity must be > 0";
        }
        this->array = new T[capacity];
        this->capacity = capacity;
        this->length = 0;
    }

    void push_back(T x) {
        if (length == capacity) {
            T *new_array = new T[capacity * 2];
            for (int i = 0; i < length; ++i) {
                new_array[i] = array[i];
            }
            delete[] array;
            array = new_array;
            capacity *= 2;
        }
        array[length++] = x;
    }

    T operator[](int i) {
        if (i < 0 || i >= length) {
            throw "Index out of range";
        }
        return array[i];
    }
private:
    T* array;
    int capacity;
    int length;
};

表示使用继承方式实现LinearList<T>的接口，具体实现的是使用动态数组来实现线性表存储，这里只有声明，没有实现，而实现部分在源文件中完成。

// array_list.cpp
#include "array_list.h"
#include <iostream>

using namespace std;

// 这里是类ArrayList<T>的具体实现部分

最后是在cpp文件中包含头文件，并补充实现接口。接下来就是如何进行编译，在此就不再展开。