我有一个对字符串进行转换的类,就像这样
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);
会很安全,但很烦人。有没有更好的方法来执行这些类型的链式操作?