在 C++ 中链接调用临时变量

Question

我有一个对字符串进行转换的类，如下所示

class transer{
    transer * parent;
protected:
    virtual string inner(const string & s) = 0;
public:
    string trans(const string & s) {
        if (parent) 
            return parent->trans(inner(s));
        else 
            return inner(s);
    }
    transer(transer * p) : parent(p) {}

    template <class T>
    T create() { return T(this); }
    template <class T, class A1>   // no variadic templates for me
    T create(A1 && a1) { return T(this, std::forward(a1)); }
};

所以我可以创建一个子类

class add_count : public transer{
    int count;
    add_count& operator=(const add_count &);
protected:
    virtual string inner(const string & s) { 
        return std::to_string((long long)count++) + s; 
    }
public:
    add_count(transer * p = 0) : transer(p), count(0) {}
};

然后我可以使用转换：

void use_transformation(transer & t){
    t.trans("string1");
    t.trans("string2");
}
void use_transformation(transer && t){
    use_trasnformation(t);
}

use_transformation(add_count().create<add_count>());

有没有更好的设计呢？如果可以的话，我想避免使用动态分配/shared_ptr，但我不确定临时对象是否会在整个调用过程中保持活动状态。我还希望能够让每个对象transer在销毁期间能够与其父对象交谈，因此临时对象也需要按正确的顺序销毁。创建链式转换并将其保存以供以后使用也很困难，因为

sometrans t = add_count().create<trans1>().create<trans2>().create<trans3>();

将保存指向不再存在的临时指针。做类似的事情

trans1 t1;
trans2 t2(&t1);
trans3 t3(&t2);

会很安全，但很烦人。有没有更好的方法来进行此类连锁操作？

Answer 1

临时变量将在完整表达式结束时以与构造它们相反的顺序被销毁。但是，请注意后者，因为无法保证评估的顺序。（当然，直接依赖关系除外：如果您需要一个临时对象才能创建下一个临时对象（如果我理解正确，这就是您的情况），那么您就安全了。）