Шаблоны выражений с иерархией, определенной на узлах в синтаксическом дереве - PullRequest
Новая
       49

Шаблоны выражений с иерархией, определенной на узлах в синтаксическом дереве

1 голос
/ 09 мая 2019

Я нашел отличное объяснение шаблонов выражений здесь . В статье мы находим базовую реализацию шаблона выражения для арифметики следующим образом (слегка адаптированную): 

#include <iostream>

template <typename T>
struct plus {
    T operator()(const T a, const T b) const { return a + b; }
};

template <class ExprT>
struct exprTraits {
    typedef ExprT expr_type;
};

template <class ExprT1, class ExprT2, class BinOp>
class BinaryExpr {
   public:
    BinaryExpr(ExprT1 e1, ExprT2 e2, BinOp op = BinOp()) : _expr1(e1), _expr2(e2), _op(op) {}
    double eval() const { return _op(_expr1.eval(), _expr2.eval()); }

   private:
    typename exprTraits<ExprT1>::expr_type _expr1;
    typename exprTraits<ExprT2>::expr_type _expr2;
    BinOp _op;
};

class Literal {
   public:
    Literal(const double v) : _val(v) {}
    double eval() const { return _val; }

   private:
    const double _val;
};

template <>
struct exprTraits<double> {
    typedef Literal expr_type;
};

class Variable {
   public:
    Variable(double& v) : _val(v) {}
    double eval() const { return _val; }

    void operator+=(double x) { _val += x; }

   private:
    double& _val;
};

class SpecialVariable : public Variable {
   public:
    SpecialVariable(double& v) : Variable{v} {};
    double eval() const { return -1000.0; }
};

template <class ExprT1, class ExprT2>
BinaryExpr<ExprT1, ExprT2, plus<double>> operator+(ExprT1 e1, ExprT2 e2) {
    return BinaryExpr<ExprT1, ExprT2, plus<double>>(e1, e2);
}

Существует три типа узлов: Literal, Variable и SpecialVariable, которые являются подклассом последних. Здесь есть признаки, позволяющие включать в выражения встроенные типы, такие как double, не заключая их в Literal.

Теперь предположим, что я хочу сделать что-то конкретное, когда я добавлю double и Variable и добавлю плюс к Variable. Я добавляю следующую функцию-член к Variable: 

void operator+=(BinaryExpr<double, Variable, plus<double>> expr) { _val += 1000.0; }

и написать небольшую тестовую программу: 

int main(int argc, char const* argv[]) {
    double xd = 2.0, yd = 5.0;
    Variable x{xd};
    SpecialVariable y{yd};
    x += 3.0 + y;
    std::cout << "result : " << std::to_string(x.eval()) << "\n";
    return 0;
}

Это, однако, работает только с Variable с, а не с SpecialVariable с, т.е. я получаю следующую ошибку компилятора: 

error: no match for ‘operator+=’ (operand types are ‘Variable’ and ‘BinaryExpr<double, SpecialVariable, plus<double> >’) x += 3.0 + y;
note:   no known conversion for argument 1 from ‘BinaryExpr<double, SpecialVariable, plus<double> >’ to ‘BinaryExpr<double, Variable, plus<double> >’

, что вполне разумно, поскольку классовые шаблоны не обязательно имеют отношение, если их аргументы шаблона имеют такое отношение.

Вопрос : как мне написать один operator+=, который принимает шаблоны выражений с типами и , возможно, с их подтипами? Я не видел учебник по шаблонам выражений, который решает эту конкретную проблему.

1 Ответ

4 голосов
/ 09 мая 2019

Вопрос: как мне написать один operator+=, который принимает шаблоны выражений с типами и, возможно, их подтипами?

Использование std::is_base_of и SFINAE 

template <typename V>
std::enable_if_t<std::is_base_of_v<Variable, V>>
   operator+= (BinaryExpr<double, V, plus<double>> expr)
 { _val += 1000.0; }

Предыдущий код компилируется в C ++ 17.

Если вы используете C ++ 14, вы должны использовать 

std::is_base_of<Variable, V>::value

вместо 

std::is_base_of_v<Variable, V>

Если вы используете C ++ 11, вы должны использовать 

typename std::enable_if<std::is_base_of<Variable, V>::value>::type

вместо 

std::enable_if_t<std::is_base_of_v<Variable, V>>
...