在C++中使用表达式模板进行符号区分

您需要一种方法来表示您的符号(即编码的表达式模板，例如 3 * x * x + 42 (，以及可以计算导数的元函数。希望你对元编程足够熟悉C++知道这意味着什么和意味着什么，但能给你一个想法：

// This should come from the expression templates
template<typename Lhs, typename Rhs>
struct plus_node;
// Metafunction that computes a derivative
template<typename T>
struct derivative;
// derivative<foo>::type is the result of computing the derivative of foo
// Derivative of lhs + rhs
template<typename Lhs, typename Rhs>
struct derivative<plus_node<Lhs, Rhs> > {
    typedef plus_node<
        typename derivative<Lhs>::type
        , typename derivative<Rhs>::type
    > type;
};
// and so on

然后，您将这两个部分(表示和计算(捆绑在一起，以便于使用。 例如 derivative(3 * x * x + 42)(6)可能意味着"在 x 中计算 6 处3 * x * x + 42的导数"。

但是，即使您确实知道编写表达式模板需要什么以及用C++编写元程序需要什么，我也不建议您这样做。模板元编程需要大量的样板文件，并且可能很乏味。相反，我将引导您访问天才的 Boost.Proto 库，该库专门设计用于帮助编写 EDSL(使用表达式模板(并对这些表达式模板进行操作。学习使用不一定容易，但我发现学习如何在不使用它的情况下实现同样的事情更难。下面是一个实际上可以理解和计算derivative(3 * x * x + 42)(6)的示例程序：

#include <iostream>
#include <boost/proto/proto.hpp>
using namespace boost::proto;
// Assuming derivative of one variable, the 'unknown'
struct unknown {};
// Boost.Proto calls this the expression wrapper
// elements of the EDSL will have this type
template<typename Expr>
struct expression;
// Boost.Proto calls this the domain
struct derived_domain
: domain<generator<expression>> {};
// We will use a context to evaluate expression templates
struct evaluation_context: callable_context<evaluation_context const> {
    double value;
    explicit evaluation_context(double value)
        : value(value)
    {}
    typedef double result_type;
    double operator()(tag::terminal, unknown) const
    { return value; }
};
// And now we can do:
// evalutation_context context(42);
// eval(expr, context);
// to evaluate an expression as though the unknown had value 42
template<typename Expr>
struct expression: extends<Expr, expression<Expr>, derived_domain> {
    typedef extends<Expr, expression<Expr>, derived_domain> base_type;
    expression(Expr const& expr = Expr())
        : base_type(expr)
    {}
    typedef double result_type;
    // We spare ourselves the need to write eval(expr, context)
    // Instead, expr(42) is available
    double operator()(double d) const
    {
        evaluation_context context(d);
        return eval(*this, context);
    }
};
// Boost.Proto calls this a transform -- we use this to operate
// on the expression templates
struct Derivative
: or_<
    when<
        terminal<unknown>
        , boost::mpl::int_<1>()
    >
    , when<
        terminal<_>
        , boost::mpl::int_<0>()
    >
    , when<
        plus<Derivative, Derivative>
        , _make_plus(Derivative(_left), Derivative(_right))
    >
    , when<
        multiplies<Derivative, Derivative>
        , _make_plus(
            _make_multiplies(Derivative(_left), _right)
            , _make_multiplies(_left, Derivative(_right))
        )
    >
    , otherwise<_>
> {};
// x is the unknown
expression<terminal<unknown>::type> const x;
// A transform works as a functor
Derivative const derivative;
int
main()
{
    double d = derivative(3 * x * x + 3)(6);
    std::cout << d << 'n';
}