表达式模板：惰性求值与领域特定语言(DSL)的编译期实现

说实话，表达式模板这个话题，我第一次接触时也觉得挺玄乎的。当时我在做一个科学计算库，需要处理大量向量运算。每次写 v = a + b + c * d 这种表达式，都会产生一堆临时对象，性能惨不忍睹。后来我翻到了 C++ 模板元编程的经典书籍，才恍然大悟——原来可以在编译期就把整个表达式树给拆解掉。

今天我们就来聊聊这个技术。它本质上就两件事：惰性求值和编译期 DSL。

什么是表达式模板？

表达式模板是一种 C++ 模板技术。它把运算表达式表示成模板类型，而不是立即执行。说白了，就是让编译器帮你构建一棵表达式树，等到真正赋值的时候才去计算。

我举个例子你就明白了。假设我们有向量类：

template<typename T>
class Vec {
    T* data_;
    size_t size_;
public:
    Vec(size_t n) : size_(n), data_(new T[n]) {}
    ~Vec() { delete[] data_; }
    
    T& operator[](size_t i) { return data_[i]; }
    const T& operator[](size_t i) const { return data_[i]; }
    
    size_t size() const { return size_; }
};

如果直接重载 operator+，返回一个新向量：

template<typename T>
Vec<T> operator+(const Vec<T>& a, const Vec<T>& b) {
    Vec<T> result(a.size());
    for (size_t i = 0; i < a.size(); ++i)
        result[i] = a[i] + b[i];
    return result;
}

那么 v = a + b + c + d 会创建多少个临时对象？三个！每个 + 都生成一个临时 Vec。这在科学计算里是致命的。

惰性求值的思路

表达式模板的思路是：不要立即计算，而是把表达式本身编码成类型。

我们定义一个表达式基类：

template<typename E>
class VecExpr {
public:
    // 返回表达式中第 i 个元素的值
    T operator[](size_t i) const { 
        return static_cast<const E&>(*this)[i]; 
    }
    size_t size() const { 
        return static_cast<const E&>(*this).size(); 
    }
};

然后定义加法表达式：

template<typename L, typename R>
class VecAdd : public VecExpr<VecAdd<L, R>> {
    const L& lhs_;
    const R& rhs_;
public:
    VecAdd(const L& lhs, const R& rhs) : lhs_(lhs), rhs_(rhs) {}
    
    auto operator[](size_t i) const { return lhs_[i] + rhs_[i]; }
    size_t size() const { return lhs_.size(); }
};

现在重载 operator+，让它返回表达式对象，而不是计算结果：

template<typename L, typename R>
VecAdd<L, R> operator+(const VecExpr<L>& lhs, const VecExpr<R>& rhs) {
    return VecAdd<L, R>(
        static_cast<const L&>(lhs),
        static_cast<const R&>(rhs)
    );
}

Vec 类也要继承 VecExpr：

class Vec : public VecExpr<Vec> {
    // ... 之前的实现 ...
    
    // 赋值运算符，接受任意表达式
    template<typename E>
    Vec& operator=(const VecExpr<E>& expr) {
        const E& e = static_cast<const E&>(expr);
        for (size_t i = 0; i < size_; ++i)
            data_[i] = e[i];
        return *this;
    }
};

现在 v = a + b + c + d 发生了什么？

• a + b 返回 VecAdd<Vec, Vec>
• (a+b) + c 返回 VecAdd<VecAdd<Vec,Vec>, Vec>
• ((a+b)+c) + d 返回 VecAdd<VecAdd<VecAdd<Vec,Vec>, Vec>, Vec>
• 赋值时，operator= 遍历一次，完成所有计算

零临时对象，一次遍历。这就是惰性求值的威力。

编译期 DSL 的构建

表达式模板的另一个妙用是构建领域特定语言（DSL）。你想想看，我们实际上是在 C++ 的类型系统里嵌入了一门小语言。

比如，我们可以定义一些操作符，让用户写出接近数学公式的代码：

// 定义一些占位符
auto _1 = placeholder<0>();
auto _2 = placeholder<1>();

// 用户代码
auto expr = _1 * _1 + 2 * _1 * _2 + _2 * _2;
// 这实际上表示 (x+y)^2

// 求值
double result = expr(3.0, 4.0);  // 49.0

怎么实现的？核心思路和向量表达式模板一样：

template<int N>
struct placeholder {
    // 占位符本身也是一个表达式
};

template<typename L, typename R>
struct add_op {
    template<typename... Args>
    auto operator()(Args... args) const {
        return L()(args...) + R()(args...);
    }
};

template<typename L, typename R>
auto operator+(L, R) {
    return add_op<L, R>{};
}

这样，_1 + _2 的类型就是 add_op<placeholder<0>, placeholder<1>>。整个表达式树在编译期就确定了。

表达式模板的典型应用场景

场景	说明	我的建议
数值计算库	向量、矩阵运算，避免临时对象	Blitz++、Eigen 都用了这个技术
解析器组合子	用模板组合解析规则	Boost.Spirit 就是典型例子
SQL 构建器	编译期检查 SQL 语法	我曾经写过一个，编译期就能发现字段名错误
图形学着色器	在 C++ 中嵌入着色器语言	编译期生成 GLSL 代码

避坑指南

知识体系总览

下面这张图总结了表达式模板的核心逻辑：

总结

表达式模板是 C++ 模板元编程里一个非常实用的技术。它把运行时开销转移到了编译期，让代码既优雅又高效。

我个人觉得，理解这个技术的核心在于转变思维：不要想着「怎么算」，而是想着「怎么描述计算」。一旦你习惯了用类型来表达运算，你就能在 C++ 里构建出各种精巧的 DSL。

嗯，这里要注意一点：表达式模板不是银弹。如果你的表达式很简单，或者你的编译器对模板展开优化不好，直接写循环可能更靠谱。但如果你在做高性能计算库、图形引擎或者解析器框架，这个技术绝对值得掌握。

---

公众号:蓝海资料掘金营，微信deep3321