基于模板的矩阵运算静态库开发：如何隐藏实现代码？

这是C++模板开发中非常常见的痛点——想要把模板类封装成静态库，同时不暴露实现代码，但模板的特性默认要求声明和定义必须在一起才能让编译器实例化。不过我们可以通过显式实例化来绕开这个限制，具体步骤如下：

1. 拆分声明与实现 #

首先把你的类声明和实现分离：

• 头文件（MatrixClass.h）只保留类的声明，移除所有模板成员函数的定义：

#ifndef __MATRIXCLASS_H__
#define __MATRIXCLASS_H__
#include<iostream>
#include<vector>

template<typename T>
class CMatrix {
public:
    CMatrix();
    ~CMatrix();
    unsigned long rows;
    unsigned long cols;
    std::vector<std::vector<T> > data;
    void setMatrixSize(unsigned long rows, unsigned long cols);
    void printMatrix();
    void add(CMatrix<T>& A, CMatrix<T>& B);
    void sub(CMatrix<T>& A, CMatrix<T>& B);
    void mul(CMatrix<T>& A, CMatrix<T>& B);
};

#endif

• 创建一个实现文件（比如MatrixClassImpl.cpp），包含头文件并实现所有成员函数，最后显式实例化你需要支持的所有数据类型：

#include "MatrixClass.h"

// 所有成员函数的实现和你原来的代码一致
template<typename T>
CMatrix<T>::CMatrix() {
    this->rows = 0;
    this->cols = 0;
    data.clear();
}

template<typename T>
CMatrix<T>::~CMatrix() {
    this->rows = 0;
    this->cols = 0;
    data.clear();
}

template<typename T>
void CMatrix<T>::setMatrixSize(unsigned long rows, unsigned long cols) {
    this->rows = rows;
    this->cols = cols;
    data.clear();
    data.resize(cols, std::vector<T>(rows, 0));
}

template<typename T>
void CMatrix<T>::printMatrix() {
    for(unsigned long i = 0; i < rows; i++) {
        for(unsigned long j = 0; j < cols; j++) {
            std::cout << data.at(i).at(j) << "\t";
        }
        std::cout << std::endl;
    }
}

template<typename T>
void CMatrix<T>::add(CMatrix<T>& A, CMatrix<T>& B) {
    if((A.rows == B.rows) && (A.cols == B.cols)) {
        for(unsigned long i = 0; i < rows; i++) {
            for(unsigned long j = 0; j < cols; j++) {
                data.at(i).at(j) = A.data.at(i).at(j) + B.data.at(i).at(j);
            }
        }
    }
}

template<typename T>
void CMatrix<T>::sub(CMatrix<T>& A, CMatrix<T>& B) {
    if((A.rows == B.rows) && (A.cols == B.cols)) {
        for(unsigned long i = 0; i < rows; i++) {
            for(unsigned long j = 0; j < cols; j++) {
                data.at(i).at(j) = A.data.at(i).at(j) - B.data.at(i).at(j);
            }
        }
    }
}

template<typename T>
void CMatrix<T>::mul(CMatrix<T>& A, CMatrix<T>& B) {
    if((A.cols == B.rows) && (rows == A.rows) && (cols == B.cols)) {
        for(unsigned long i = 0; i < A.rows; i++) {
            for(unsigned long j = 0; j < B.cols; j++) {
                for(unsigned long k = 0; k < A.cols; k++) {
                    data.at(i).at(j) += A.data.at(i).at(k) * B.data.at(k).at(j);
                }
            }
        }
    }
}

// 关键：显式实例化所有需要支持的类型
template class CMatrix<short>;
template class CMatrix<int>;
template class CMatrix<long>;
template class CMatrix<long long>;
template class CMatrix<float>;
template class CMatrix<double>;
template class CMatrix<long double>;

2. 编译生成静态库 #

用编译器编译实现文件，再打包成静态库。比如用GCC的命令：

# 编译成目标文件
g++ -c MatrixClassImpl.cpp -o MatrixClassImpl.o
# 打包成静态库
ar rcs libmatrix.a MatrixClassImpl.o

3. 提供给用户的文件 #

你只需要把MatrixClass.h和libmatrix.a提供给用户即可，完全不需要暴露MatrixClassImpl.cpp。用户编译自己的代码时，只需要链接这个静态库：

g++ user_code.cpp -o user_program -L. -lmatrix

原理说明 #

C++模板是编译时实例化的，通常编译器需要看到模板的定义才能生成特定类型的代码。而显式实例化会让编译器在编译你的实现文件时，就提前把你指定的所有类型的CMatrix类代码生成出来，并存放到静态库中。用户的代码编译时，链接器会从静态库中找到对应的实例化代码，不需要访问模板的实现。

注意事项 #

• 如果后续需要支持新的数据类型，你需要修改MatrixClassImpl.cpp，添加对应的显式实例化语句，然后重新编译静态库。
• 你的当前代码中rows、cols、data都是public成员，用户仍然可以直接访问这些成员。如果想要更彻底的封装，可以考虑使用Pimpl惯用法，但这会增加模板实现的复杂度，如果你只是想隐藏函数实现，显式实例化已经足够。

内容的提问来源于stack exchange，提问作者Harry