Expression Templates（表达式模板）是C++模板元编程领域的一项经典技术，核心目标是通过编译期构建表达式结构，延迟表达式的实际计算时机，从而消除数值计算过程中产生的大量临时对象，提升计算性能。
传统数值计算的问题
我们先看一个常见的向量加法场景，假设我们有一个简单的向量类，支持两个向量相加的操作：
#include <vector>
#include <iostream>
class Vector {
public:
std::vector<double> data;
Vector(int size) : data(size) {}
Vector(const std::vector<double>& d) : data(d) {}
// 重载+运算符，返回新的Vector对象
Vector operator+(const Vector& other) const {
if (data.size() != other.data.size()) {
throw std::invalid_argument("Vector size mismatch");
}
Vector result(data.size());
for (size_t i = 0; i < data.size(); ++i) {
result.data[i] = data[i] + other.data[i];
}
return result;
}
void print() const {
for (double val : data) {
std::cout << val << " ";
}
std::cout << std::endl;
}
};
如果执行Vector c = a + b + d;这样的表达式，按照运算符的结合顺序，会先计算a + b生成一个临时Vector对象，再把这个临时对象和d相加生成另一个临时对象，最后赋值给c。这个过程中会产生两次临时对象的构造、内存分配和数据拷贝，当向量规模较大时，这些开销会非常明显。
表达式模板的核心思想
表达式模板的核心思路是：不直接让运算符返回计算结果，而是返回一个描述表达式结构的轻量级模板对象，只有当最终需要获取结果的时候（比如赋值给Vector对象时），才遍历这个表达式结构完成实际计算，这样就能避免中间临时对象的产生。
我们需要先定义一个表达式的基类模板，所有具体的表达式类型都继承自这个基类，然后通过模板特化来表示不同的运算：
#include <vector>
#include <iostream>
#include <type_traits>
// 表达式基类，定义统一的接口
template <typename Expr>
struct Expression {
// 隐式转换为具体表达式类型
const Expr& self() const {
return static_cast<const Expr&>(*this);
}
// 获取表达式在第i个元素的值
double operator[](size_t i) const {
return self()[i];
}
// 获取表达式的长度
size_t size() const {
return self().size();
}
};
实现具体的表达式模板
向量表达式
首先让之前的Vector类继承自Expression模板，成为可参与表达式模板的向量表达式：
class Vector : public Expression<Vector> {
public:
std::vector<double> data;
Vector(int size) : data(size) {}
Vector(const std::vector<double>& d) : data(d) {}
// 实现Expression要求的接口
double operator[](size_t i) const {
return data[i];
}
size_t size() const {
return data.size();
}
// 赋值运算符，接收任意表达式类型，触发实际计算
template <typename Expr>
Vector& operator=(const Expression<Expr>& expr) {
const Expr& e = expr.self();
if (data.size() != e.size()) {
data.resize(e.size());
}
for (size_t i = 0; i < e.size(); ++i) {
data[i] = e[i];
}
return *this;
}
};
加法表达式模板
接下来定义加法表达式的模板，它保存两个子表达式的引用，在获取元素值时才计算两个子表达式对应元素的和：
// 加法表达式模板
template <typename Lhs, typename Rhs>
struct AddExpression : public Expression<AddExpression<Lhs, Rhs>> {
const Lhs& lhs;
const Rhs& rhs;
AddExpression(const Lhs& l, const Rhs& r) : lhs(l), rhs(r) {}
// 获取第i个元素的和
double operator[](size_t i) const {
return lhs[i] + rhs[i];
}
// 获取表达式长度，取两个子表达式中较大的长度（实际使用时可加校验）
size_t size() const {
return lhs.size();
}
};
// 重载Vector的+运算符，返回加法表达式模板对象
template <typename Lhs, typename Rhs>
AddExpression<Lhs, Rhs> operator+(const Expression<Lhs>& lhs, const Expression<Rhs>& rhs) {
return AddExpression<Lhs, Rhs>(lhs.self(), rhs.self());
}
表达式模板的效果验证
现在我们用新的实现来执行Vector c = a + b + d;的表达式：
int main() {
Vector a({1.0, 2.0, 3.0});
Vector b({4.0, 5.0, 6.0});
Vector d({7.0, 8.0, 9.0});
Vector c(3);
// 此时a + b返回AddExpression对象，再和d相加还是返回AddExpression对象，没有实际计算
// 赋值给c时，才会遍历表达式计算每个位置的和
c = a + b + d;
c.print(); // 输出 12 15 18
return 0;
}
在这个执行过程中，a + b + d只会生成一个嵌套的AddExpression对象，不会创建任何中间的Vector临时对象，赋值给c的时候才会一次性完成所有元素的计算，完全消除了临时对象的开销。
表达式模板的适用场景和注意事项
表达式模板非常适合向量、矩阵、张量这类数值计算场景，尤其是计算表达式较长、中间结果规模较大的情况，优化效果会非常明显。但它也有一些需要注意的点：
- 表达式模板会增加编译期的复杂度，可能会导致编译时间变长，尤其是复杂的嵌套表达式。
- 表达式模板对象保存的是子表达式的引用，需要注意子表达式的生命周期，避免悬垂引用的问题。
- 对于非常简单的短表达式，表达式模板带来的编译期开销可能抵消运行时的优化收益，需要根据实际场景选择是否使用。
很多成熟的数值计算库比如Eigen、Boost.uBLAS都大量使用了表达式模板技术，在保证接口简洁的同时，实现了接近手写循环的计算性能。
Expression_TemplatesC++模板元编程数值计算优化修改时间：2026-07-09 22:15:36