Question

我有两个类，一个表达式（SE）和两个表达式（ME）捆绑。这个包本身就是一个表达式，因此它可以是另一个包的元素。

struct SE {
    SE(char id, char n) : id(id), n(n) {}

    size_t size() const { return n; }
    char *eval(char *b) const { b[0]=id; return b+1; }

    char id, n;
};

template <typename LHS>
struct ME {
    ME(const LHS& l, const SE& r) : lhs(l), rhs(r) { }

    size_t size() const { return rhs.size(); }
    char *eval(char *b) const { *b++='('; b=lhs.eval(b); *b++=','; b=rhs.eval(b); *b++=')'; return b; }

    LHS lhs;
    SE rhs;
};

捆绑包的构造基于数据成员n执行简单的有效性检查，可通过方法ME在size中进行访问。 eval方法使用数据成员id进行了一些概括。 n和id在编译时都未知。

对于这两个类，我都重写了逗号运算符，以便它执行将多个单个表达式递归捆绑到嵌套捆绑中的过程。

auto SE::operator,(const SE& r) { return ME<SE>(*this, r); }
auto ME<LHS>::operator,(const SE& r) { return ME<ME<LHS>>(*this, r); }

我希望在构建整个捆绑包之后，在整个捆绑包上触发方法eval。示例：

SE('a',1);                        // prints 'a'
SE('a',1), SE('b',1);             // prints '(a,b)'
SE('a',1), SE('b',1), SE('c',1);  // prints '((a,b),c)'

一种实现方法是使用类的析构函数并添加标志is_outer，该标志在SE和ME的构造过程中会适当更新。当这些类中的任何一个被破坏时，如果标志指示这是最外层类，则将触发eval。下面是完整的演示。

在下面的godbolt上测试简单的demo函数，在我看来，编译器生成的代码超出了严格的要求。尽管id和n在编译时未知，但是表达式的最终类型应该是。我希望捆绑软件的整个结构减少到只将几个数字移到正确的位置，然后检查断言，但实际上它实际上做的更多。

是否有可能在编译时产生更多的构造部分？

#include <iostream>
#include <cassert>
#include <string>
#include <sstream>
using namespace std;

// forward declaration
template <typename LHS> struct ME;

struct SE {
    SE(char id, char n) : id(id), n(n), outer(true)  {}
    SE(const SE& expr) : id(expr.id), n(expr.n), outer(false) {}

    ME<SE> operator,(const SE& r);

    size_t size() const { return n; }
    char *eval(char *b) const { b[0]=id; return b+1; }

    ~SE() { if(outer) { char b[20] = {}; char *p=eval(b); *p++='\n'; cout << b; } }

    char id, n;
    mutable bool outer;
};

template <typename LHS>
struct ME {
    ME(const LHS& l, const SE& r)
        : lhs(l), rhs(r), outer(true)  // tentatively set to true
    { l.outer = r.outer = false;  assert(l.size() == r.size()); } // reset flag for arguments
    ME(const ME<LHS>& expr)
        : lhs(expr.lhs), rhs(expr.rhs), outer(false) {}

    size_t size() const { return rhs.size(); }
    char *eval(char *b) const { *b++='('; b=lhs.eval(b); *b++=','; b=rhs.eval(b); *b++=')'; return b; }

    auto operator,(const SE& r) { return ME<ME<LHS>>(*this, r); }

    ~ME() { if(outer) { char b[20] = {}; char *p=eval(b); *p++='\n'; cout << b; } }

    LHS lhs;
    SE rhs;
    mutable bool outer;
};

ME<SE> SE::operator,(const SE& r) { return ME<SE>(*this, r); }

void demo(char a, char na, char b, char nb, char c, char nc) {
    SE(a, na), SE(b,nb), SE(c,nc);   // prints '((a,b),c)'
}

int main() {
    demo('a',1,'b',1,'c',1);
    return 0;
}

Answer 1

您遵循的一般模式是表达式模板。阅读其他人如何做会有所帮助。

通常，表达式模板会大量使用CRTP，并且不会存储副本。

我相信我会因为复制而发现错误。

通常取T&&并存储T&或T&&。

通常，将表达式模板分配给目标后，它们就会终止（并执行）；你不想那样。由于C ++缺乏“走来走去”的特性，因此您必须在（名义上）运行时检查“不应执行”。

您可以存储指针并使用null代替“引用/值和布尔值”。

我无法弄清楚如何确定运行constexpr的工作。但是有可能。

使用表达式：如何最小化运行时构造时间

1 个答案: