我在 https://en.wikipedia.org/wiki/Expression_templates 查看表达式模板的示例.然后我尝试制作一个简单的符号表达式树，即添加常量和变量，如 a + b + 10。所以我从

#include <iostream>


template<typename E>
class Expression {
public:
    std::ostream& print(std::ostream& os) const
    {
        return expression().print(os);
    }
    E const& expression() const { return static_cast<E const&>(*this); }
};

class Var : public Expression<Var> {
public:
    Var(const char name)
            : name_(name)
    {}

    std::ostream& print(std::ostream& os) const
    {
        return os << name_;
    }
private:
    const char name_;
};

class Constant : public Expression<Constant> {
public:
    Constant(const double value)
            : value_(value)
    {}

    std::ostream& print(std::ostream& os) const
    {
        return os << value_;
    }

private:
    const double value_;
};

template<typename E1, typename E2>
class ExpressionSum : public Expression<ExpressionSum<E1,E2>> {
    E1 const& u_;
    E2 const& v_;
public:
    ExpressionSum(E1 const& u, E2 const& v) : u_(u), v_(v)
    {
    }

    std::ostream& print(std::ostream& os) const
    {
        os << "(";
        u_.print(os);
        os << " + ";
        v_.print(os);
        os << ")";
        return os;
    }
};
template <typename E1, typename E2>
ExpressionSum<E1,E2> operator+(Expression<E1> const& u, Expression<E2> const& v) {
    return ExpressionSum<E1, E2>(u.expression(), v.expression());
}

int main() {
    Var a('a');
    Var b('b');
    Constant c(1.0);

    auto expr = a + b + c;
    expr.print(std::cout);
    std::cout << std::endl;

    auto expr2 = expr + Constant{2.0};
    expr2.print(std::cout);
    std::cout << std::endl;
}

表达式expr很好，但我不能重复使用 expr构建另一个表达式，如 expr2自临时ExpressionSum的 a+b已经被摧毁了。有没有办法在表达式中存储这些临时变量？

最佳答案

避免 CRTP:使用 Argument-Dependent Lookup 来简化库

我们想让事情尽可能简单。 Curiously Recurring Template Pattern(及其亲戚)是功能强大的工具，但它们会增加编译时间，并且在您想扩展您正在做的事情时会很麻烦。

利用 argument dependent lookup ，我们可以在没有基类的情况下实现运算符重载。这大大简化了库的设计。我将在下面给出的示例中对此进行更多解释

避免生命周期问题:按值存储子表达式，除非显式使用 std::ref

我们想让这个库保持简单。表达式可以是常量、一元运算和输入，也可以是二元运算和输入。没有任何类不变量——输入可以取任何值，操作本身是根据它的类型存储的，所以它只能有 1 个值。

这意味着我们可以将表达式表示为聚合类型，使它们易于构造、易于复制、易于破坏，并减少编译时间和生成的二进制文件的大小。

namespace expr // We need to put them in a namespace so we can use ADL
{
    template<class Value>
    class Constant
    {
       public:
        Value value;
    };

    template<class Op, class Input>
    class UnaryOp
    {
       public:
        Op op;
        Input input; 
    };
    template<class Op, class Left, class Right>
    class BinaryOp
    {
       public:
        Op op;
        Left lhs;
        Right rhs; 
    };
}

简化运算符重载:使用命名空间作用域

如果我们在命名空间中编写运算符重载，只有在处理来自该命名空间的类型时才会考虑它们。这意味着我们可以避免使用基类，并且可以使用不受约束的模板。

namespace expr 
{
    template<class A>
    auto operator-(A const& a)
    {
        return UnaryOp<Negate, A>{{}, a}; 
    }
    template<class A, class B>
    auto operator+(A const& a, B const& b) 
    {
        return BinaryOp<Plus, A, B>{{}, a, b}; 
    }
    template<class A, class B>
    auto operator-(A const& a, B const& b) 
    {
        return BinaryOp<Minus, A, B>{{}, a, b}; 
    }
    template<class A, class B>
    auto operator*(A const& a, B const& b) {
        return BinaryOp<Times, A, B>{{}, a, b}; 
    }
}

简化评估:操作类型知道如何评估他们的输入

这实现起来非常简单 - 基本上，任何操作都是一个知道如何评估输入的仿函数类型。在 C++20 中，这可以通过 lambda 来实现，但出于我们的目的，我们将重载 operator()。

namespace expr {
    class Negate {
        template<class A>
        constexpr auto operator()(A&& a) const 
            noexcept(noexcept(-a))
            -> decltype(-a)
        {
            return -a; 
        }
    };
    class Plus {
    public:
        template<class A, class B>
        constexpr auto operator()(A&& a, B&& b) const
            noexcept(noexcept(a + b))
            -> decltype(a + b) 
        {
            return a + b; 
        }
    };
    class Minus {
    public:
        template<class A, class B>
        constexpr auto operator()(A&& a, B&& b) const
            noexcept(noexcept(a - b))
            -> decltype(a - b) 
        {
            return a - b; 
        }
    };
    class Times {
    public:
        template<class A, class B>
        constexpr auto operator()(A&& a, B&& b) const
            noexcept(noexcept(a * b))
            -> decltype(a * b) 
        {
            return a * b; 
        }
    };
}

利用命名空间范围的模式匹配evaluate

在命名空间范围内编写 evaluate 函数时，我们可以利用模式匹配和递归，而不是将其作为成员函数。

namespace expr
{
    // This one is applied to things that aren't constants or expressions
    template<class Thing>
    auto evaluate(Thing const& t) -> Thing const& {
        return t; 
    }
    template<class Value>
    auto evaluate(Constant<Value> const& value) {
        return evaluate(value.value);
    }
    template<class Op, class Input>
    auto evaluate(UnaryOp<Op, Input> const& expr) {
        return expr.op(evaluate(expr.value)); 
    }
    template<class Op, class LHS, class RHS>
    auto evaluate(BinaryOp<Op, LHS, RHS> const& expr) {
        return expr.op(evaluate(expr.lhs), evaluate(expr.rhs)); 
    }
}

关于C++ 表达式模板生命周期，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56261171/