通过基指针C++设计模式删除派生类

您有两种方法可以实现此目的。 如果要使用unique_ptr则需要创建一个函子，该函子枚举所创建的类型，然后通过开关来调用正确的删除版本。 这不是最好的解决方案，因为它要求每次将新类型添加到层次结构时更新枚举和函子。 您需要这样做的原因是删除器是unique_ptr类型的一部分。

另一种选择是切换到使用std::shared_ptr.shared_ptr的删除器不是类型的一部分，而是内部的一部分。 这意味着，当您创建派生类的shared_ptr并将其存储在基类的shared_ptr中时，它会记住它实际上指向派生类。 使用它会使你看起来像

int main(int argc, char** argv)
{
int cl = 1;
{
std::shared_ptr<Base> d1;
switch (cl)
{
case 1:
{
d1 = std::make_shared<Derived1>();
static_cast<Derived1*>(d1.get())->Special1();
break;
}
case 2:
{
d1 = std::make_shared<Derived2>();
static_cast<Derived2*>(d1.get())->Special2();
break;
}
case 3:
{
d1 = std::make_shared<Derived3>();
static_cast<Derived3*>(d1.get())->Special3();
break;
}
}
d1.get()->SetLogger();
d1.get()->SetStatus();
d1.get()->SetTimer();
}
return 0;
}

最好是以某种方式重写代码以避免这些问题。

示例 1：使用函数共享通用代码

void PostProcess(Base &base)
{
base.SetLogger();
base.SetStatus();
base.SetTimer();
}
int main(int argc, char** argv)
{
int cl = 1;
{
switch (cl)
{
case 1:
{
// Example with an object on the stack
Derived1 d1;
d1.Special1();
PostProcess(d1);
break;
}
case 2:
{
// Example using make_unique
auto d2 = std::make_unique<Derived2>();
d2->Special2();
PostProcess(*d2);
break;
}
case 3:
{
// Example similar to your syntax
std::unique_ptr<Derived3> d3(new Derived3());
d3->Special3();
PostProcess(*d3);
break;
}
}
}
return 0;
}

示例 2：使用模板共享代码

主要思想是抽象差异，以便通用代码可用于处理所有派生类型

// Fix different naming (if you cannot modify existing classes)
void Special(Derived1 &d1) { d1.Special1(); }
void Special(Derived2 &d2) { d2.Special2(); }
void Special(Derived3 &d3) { d3.Special3(); }
// Use a template function to re-use code
template <class T> void Process()
{
auto d = std::make_unique<T>();
Special(*d);
d->SetLogger();
d->SetStatus();
d->SetTimer();
}

此时，您可以像这样修改开关大小写：

case 1:
Process<Derived1>();
break;
// Similar code for other cases…

示例 3：创建代理类以具有 OO 设计

这个想法是有一个平行的类层次结构，以便你的原始类型仍然服从你所需的约束，但有一个可以使用向量表的代理。

class BaseProxy {
public:
virtual ~BaseProxy() { }
virtual void Special() = 0;
};
// Example where you can take a reference to an external object 
// that is expected to live longer than the proxy...
class Derived1Proxy : public BaseProxy
{
public:
Derived1Proxy(Derived1 &d1_) : d1(d1_) { }
void Special() override { d1.Special1(); }
private:
Derived1 &d1;
};
// Example where your proxy contain the Derived object
class Derived2Proxy : public BaseProxy
{
public:
Derived2Proxy() { }
void Special() override { d2.Special2(); }
private:
Derived2 d2;
};
// Example where you want to ensure that the derived object live as long as required 
class Derived3Proxy : public BaseProxy
{
public:
Derived3Proxy(std::shared_ptr<Derived3> p3_) : p3(p3_) { }
void Special() override { d3->Special3(); }
private:
std::shared_ptr<Derived3> p3;
};
std::unique_ptr<BaseProxy> GetProxy(int c1)
{
case 1:
return std::make_unique<Derived1Proxy>(derived1Object);
// other case...
}

您可以根据需要调整该代码。