C++ 可克隆的混合
C++ Cloneable mixin
我有几个类需要定义以下clone
函数:
struct Base
{
virtual Base * clone() const = 0;
};
struct A : public Base
{
Base * clone() const {
return new A(*this);
}
};
struct B : public Base
{
Base * clone() const {
return new B(*this);
}
};
struct X : public Base2
{
Base2 * clone() const {
return new X(*this);
}
};
我正在尝试使用可克隆的混合来避免这种冗余代码:
template <typename BASE, typename TYPE>
class CloneableMixin
{
public:
BASE*clone() const {
return new TYPE( dynamic_cast<const TYPE &>(*this) );
}
};
struct A : public Base, public CloneableMixin<Base, A>
{
};
CloneableMixin
new TYPE(*this)
中,*this
属于 CloneableMixin<BASE, TYPE>
型更新:CloneableMixin
可以dynamic_cast
正确的类型。但是现在我有另一个问题:CloneableMixin::clone
没有成功覆盖Base::clone
,因此编译器报告A是抽象类型。
巧妙地使用virtual
继承可以让CloneableMixin::clone
覆盖Base::clone
吗?我应该为此使用一些宏吗?
您知道解决所有这些冗余代码的方法吗?
虚拟继承的巧妙使用能否允许CloneableMixin::clone覆盖Base::clone?
您的CloneableMixin<Base,Derived>
不能覆盖任何Base
方法 - 要么多态或通过隐藏 - 因为CloneableMixin<Base,Derived>
不是从Base
派生的。
另一方面,如果CloneableMixin<Base,Derived>
是从Base
派生出来的你不再需要它成为混合,因为——
class Derived : public CloneableMixin<Base,Derived> {....};
将继承Base
.
因此,对于示例的需求,此处说明的解决方案就足够了:
#include <iostream>
// cloner v1.0
template <class Base, class Derived>
struct cloner : Base
{
Base *clone() const override {
return new Derived( dynamic_cast<const Derived &>(*this) );
}
~cloner() override {};
};
struct Base
{
virtual Base * clone() const = 0;
Base() {
std::cout << "Base()" << std::endl;
}
virtual ~Base() {
std::cout << "~Base()" << std::endl;
}
};
struct A : cloner<Base,A>
{
A() {
std::cout << "A()" << std::endl;
}
~A() override {
std::cout << "~A()" << std::endl;
}
};
int main()
{
A a;
Base * pb = a.clone();
delete pb;
}
(如果您正在编译 C++03 标准而不是 C++11,那么您可以只需删除 override
关键字的出现次数即可。
此解决方案将分解为一些更真实的类层次结构,例如,在模板方法模式的下图中:
#include <iostream>
#include <memory>
using namespace std;
// cloner v1.0
template<class B, class D>
struct cloner : B
{
B *clone() const override {
return new D(dynamic_cast<D const&>(*this));
}
~cloner() override {}
};
/* Abstract base class `abstract` keeps the state for all derivatives
and has some pure virtual methods. It has some non-default
constructors.
*/
struct abstract
{
virtual ~abstract() {
cout << "~abstract()" << endl;
}
int get_state() const {
return _state;
}
void run() {
cout << "abstract::run()" << endl;
a_root_method();
another_root_method();
}
virtual void a_root_method() = 0;
virtual void another_root_method() = 0;
virtual abstract * clone() const = 0;
protected:
abstract()
: _state(0) {
cout << "abstract(): state = " << get_state() << endl;
}
explicit abstract(int state) : _state(state) {
cout << "abstract(" << state << ") : state = "
<< get_state() << endl;
}
int _state;
};
/* Concrete class `concrete` inherits `abstract`
and implements the pure virtual methods.
It echoes the constructors of `abstract`. Since `concrete`
is concrete, it requires cloneability.
*/
struct concrete : cloner<abstract,concrete>
{
concrete() {
cout << "concrete(): state = " << get_state() << endl;
}
explicit concrete(int state) : abstract(state) { //<- Barf!
cout << "concrete(" << state << ") : state = "
<< get_state() << endl;
}
~concrete() override {
cout << "~concrete()" << endl;
}
void a_root_method() override {
++_state;
cout << "concrete::a_root_method() : state = "
<< get_state() << endl;
}
void another_root_method() override {
--_state;
cout << "concrete::another_root_method() : state = "
<< get_state() << endl;
}
};
int main(int argc, char **argv)
{
concrete c1;
unique_ptr<abstract> pr(new concrete(c1));
pr->a_root_method();
pr->another_root_method();
unique_ptr<abstract> pr1(pr->clone());
pr1->a_root_method();
return 0;
}
当我们尝试构建它时,编译器将在初始化abstract(state)
在concrete
的结构中(在Barf!
评论(,说:
error: type 'abstract' is not a direct or virtual base of 'concrete'
或大意如此的话。事实上,concrete
的直接基础并不abstract
但是cloner<abstract,concrete>
.但是,我们不能将构造函数重写为:
/*Plan B*/ explicit concrete(int state) : cloner<abstract,concrete>(state){....}
因为没有这样的构造函数
cloner<abstract,concrete>::cloner<abstract,concrete>(int)
但编译器的诊断建议修复。这是虚拟的继承可以提供帮助。我们需要abstract
才能成为concrete
的虚拟基地,这实际上意味着"concrete
的荣誉直接基地",我们可以实现这一目标只需使B
成为cloner<B,D>
的虚拟基础:
// cloner v1.1
template<class B, class D>
struct cloner : virtual B
{
B *clone() const override {
return new D(dynamic_cast<D const&>(*this));
}
~cloner() override {}
};
有了这个,我们有一个干净的构建和输出:
abstract(): state = 0
concrete(): state = 0
concrete::a_root_method() : state = 1
concrete::another_root_method() : state = 0
concrete::a_root_method() : state = 1
~concrete()
~abstract()
~concrete()
~abstract()
~concrete()
~abstract()
原则上有充分的理由警惕虚拟继承并至少将其用于具有建筑理由 - 不是为了解决方法,因为我们刚才使用了它。
如果我们更喜欢没有虚拟继承来解决这个问题,那么我们必须以某种方式确保有一个构造函数 cloner<B,D>
呼应任何B
的构造,为任意B
。然后任何相应的D
的构造函数将能够初始化其直接基cloner<B,D>
无论论点是什么。
这是 C++03 的白日梦,但具有可变参数模板的魔力C++11 中的参数很容易:
// cloner v1.2
template<class B, class D>
struct cloner : B
{
B *clone() const override {
return new D(dynamic_cast<D const&>(*this));
}
~cloner() override {}
// "All purpose constructor"
template<typename... Args>
explicit cloner(Args... args)
: B(args...){}
};
有了这个,我们可以将concrete
构造函数重写为 /*Plan B*/
,并且同样,我们有一个正确的构建和可执行文件。
在实例化可克隆的混合期间,派生类仍处于不完整的类型中。您可以尝试添加众所周知的额外间接关系,如下所示:
template
<
typename Derived
>
class Cloneable
:
private CloneableBase
{
public:
Derived* clone() const
{
return static_cast<Derived*>(this->do_clone());
}
private:
virtual Cloneable* do_clone() const
{
return new Derived(static_cast<const Derived&>(*this));
}
};
class CloneableBase
{
public:
CloneableBase* clone() const
{
return do_clone();
}
private:
virtual CloneableBase* do_clone() const=0;
};
class MyClass: public Cloneable<MyClass>;
- 混合组合和继承的C++问题
- 在混合代码库中将C转换为C++时出现许多包含错误
- D3D11-将混合权重和索引传递到顶点着色器
- C++分数混合比较运算符错误
- 是否可以混合使用SFINAE和模板专业化?
- 如何在 Python C++ 混合库中调试非确定性分段错误?
- 使用 Boost.Spirit 解析具有混合数据类型的 OBJ 文件?
- C++11 中的混合列表初始化
- C++以迭代方式搜索混合类型地图
- #pragma(*诊断)当将Clang分析器与GCC编译器混合时
- 混合 Rcpp 模块和 Rcpp::export
- C++/CLI 混合托管/本机 DLL 不起作用
- 在C++中混合覆盖和重载
- 关于 Direct3D9 中的 alpha 混合的问题
- 使用英特尔内部函数 (AVX) 中的混合说明
- C++ 中混合二进制/文本日志记录的最佳做法
- Fortran 和 C++ 的混合编程:Fortran 不能调用C++子程序
- 错误:在 C++ 目标 c 混合'self'使用未声明的标识符
- 是否有一个版本的glCopyImageSubData在Openg GL中使用混合?
- 为什么这个混合继承程序给出错误的输出?