我确定我在这里遗漏了一些基本的东西，但我无法理解它。

假设我们有几个可能的 Manager 实现处理 Base 类型对象的类.应该可以定义在运行时使用哪个实现。

基于Manager的实现, 他们将必须从 Base 设置和获取特定属性, 因此推导 DerivedA和 DerivedB他们在内部使用。有没有办法避免在 Handle 中向下转换参数的需要？方法以获得特定于实现的属性？

class Base { /* Abstract class with common properties */ };
class DerivedA : public Base { /* DerivedA-specific properties */ };
class DerivedB : public Base { /* DerivedB-specific properties */ };

class IManager { /* These functions must be implemented by every Manager implementation */
public:
    virtual Base* Create() = 0;
    virtual void Handle(Base*) = 0;
};

class AManager : public IManager
{
public:
    Base* Create() override { return new DerivedA(); }
    void Handle(Base* pFoo) override 
    { 
        // Now if we want to access pFoo's specific properties, we will need to dynamic_cast it
    }
};

class BManager : public IManager
{
public:
    Base* Create() override { return new DerivedB(); }
    void Handle(Base* pBar) override { /* same here */ }
};

void Run(bool useAManager)
{
    IManager* pManager = nullptr;

    if (useAManager)
        pManager = new AManager();
    else
        pManager = new BManager();

    Base* pData = pManager->Create();
    /* use Base specific properties ... */
    pManager->Handle(pData);
}

编辑:感谢大家的宝贵意见。我会接受@jpo38 的帖子，因为它为这个问题提供了一个可能的解决方案。然而，经过一番考虑，我发现类设计存在潜在问题。

最佳答案

您可以使用 visitor pattern .在您的示例中，这将是:

class DerivedA;
class DerivedB;
class Visitor
{ 
public:
    virtual void visitA( DerivedA& a ) = 0;
    virtual void visitB( DerivedB& b ) = 0;
};


class Base 
{ 
public:
    virtual void Accept( Visitor& visitor ) = 0;
};

class DerivedA : public Base 
{ 
public:
    virtual void Accept( Visitor& visitor ) { visitor.visitA( *this ); }
};

class DerivedB : public Base 
{ 
public:
    virtual void Accept( Visitor& visitor ) { visitor.visitB( *this ); }
};

然后，从 AManager 或 BManager:

void Handle(Base* pFoo) 
{ 
    class MyVisitor : public Visitor
    {
    public:
        virtual void visitA( DerivedA& a )
        {
             // do somethiong specific to a, you have access to DerivedA
        }
        virtual void visitB( DerivedB& b )
        {
             // do somethiong specific to b, you have access to DerivedB
        }
    };
    MyVisitor v;
    pFoo->Accept( v );
}

访问者模式的缺点是每次你想做一些特定的事情时你都必须定义一个新的访问者类。

你也可以考虑这样做(但我绝对推荐访问者，如果你稍后添加 DerivedC 或者想通过共享访问者类共享一些特定操作，非常有帮助)。

class Base 
{ 
public:
    virtual DerivedA* GetAsA() = 0;
    virtual DerivedB* GetAsB() = 0;
};

class DerivedA : public Base 
{ 
public:
    virtual DerivedA* GetAsA() { return this; }
    virtual DerivedB* GetAsB() { return NULL; }
};

class DerivedB : public Base 
{ 
public:
    virtual DerivedA* GetAsA() { return NULL; }
    virtual DerivedB* GetAsB() { return this; }
};

然后，从 AManager 或 BManager:

void Handle(Base* pFoo) 
{ 
    if ( pFoo->GetAsA() )
    {
        // use GetAsA to access DerivedA object avoiding downcasting
    }
    if ( pFoo->GetAsB() )
    {
        // use GetAsB to access DerivedB object avoiding downcasting
    }
}

关于c++ - 拥有接口(interface)和基类时如何避免向下转型？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24983039/