调用从基类指针向右free函数/参考

Question

让一个类层次结构：

class Base { virtual ~Base() throw(); }; 

class DerivedA : public Base { }; 

class DerivedB : public Base { }; 

我想有一些具体到每一个派生类的代码。但是，该代码也是特定于使用此类层次结构的应用程序的，我不想将这种派生类专用代码嵌入到这些派生类中。为了避免这样做，我想过写免费功能：

void DerivedASpecificWork(DerivedA da); 

void DerivedBSpecificWork(DerivedB db); 

然而，通过参考/指向一个基本给定一个派生类的实例时，我没有进入实际类型的实例，因此不能调用适当的Derived * SpecificWork（）函数。

我想知道是否有nome的设计模式，可以让我在不知道实例的实际类型的情况下调用派生类特定的函数，即具有与虚函数提供的相同机制，但而不需要这些虚拟函数，这就需要我将特定于应用程序的代码嵌入到该类层次结构中。

实际上，为什么我想这样做是为了提供有关由Lua脚本调用的本机实现的函数内发生的异常的信息。每个异常都带有自己的一组信息，我想在脚本中表示错误的方式取决于异常的类型。我可以在基类中创建一个由派生类实现的纯虚方法，但这需要我将Lua相关的代码嵌入到我的异常层次结构中，这是我不想做的，因为Lua是特定于使用该异常层次的应用程序。

另外我不能使用C++ 11。

谢谢。

Answer 1

可能多桥模式可以帮助你。

当您想要避免抽象与其实现之间的永久绑定时，可以使用此模式。

（我没有看到你关于使用C++ 11的限制评论，但你可以删除std::unique_ptr，std::move和override关键字）

class AppSpecificImp 
{ 
public: 
    virtual void DoWork() = 0; 
}; 

class Base 
{ 
public: 
    virtual ~Base() throw(); 

    virtual DoWork() = 0; 
}; 

class DerivedA : public Base 
{ 
public: 
    DerivedA(std::unique_ptr<AppSpecificImp> appImp) 
     : imp(std::move(appImp)) 
    { 
    } 

    void DoWork() override 
    { 
     // DerivedA specific code 

     imp->DoWork(); 
    } 

private: 
    std::unique_ptr<AppSpecificImp> imp; 
}; 

class DerivedB : public Base 
{ 
public: 
    DerivedB(std::unique_ptr<AppSpecificImp> appImp) 
     : imp(std::move(appImp)) 
    { 
    } 

    void DoWork() override 
    { 
     // DerivedB specific code 

     imp->DoWork(); 
    } 

private: 
    std::unique_ptr<AppSpecificImp> imp; 
}; 

编辑显示访问者模式用法：

随着访客模式，你可以做你想要的，但更多的努力。

class Visitor 
{ 
public: 
    virtual void VisitDerivedA(DerivedA* object) = 0; 

    virtual void VisitDerivedB(DerivedB* object) = 0; 
}; 

class Base 
{ 
public: 
    virtual void Visit(Visitor* visitor) = 0; 
}; 

class DerivedA : public Base 
{ 
public: 
    virtual void Visit(Visitor* visitor) 
    { 
     visitor->VisitDerivedA(this); 
    } 
}; 

class DerivedB : public Base 
{ 
public: 
    virtual void Visit(Visitor* visitor) 
    { 
     visitor->VisitDerivedB(this); 
    } 
}; 

class AppSpecificVisitor : public Visitor 
{ 
public: 
    void VisitDerivedA(DerivedA* object) 
    { 
     // Do any work related to DerivedA class 
    } 

    void VisitDerivedB(DerivedB* object) 
    { 
     // Do any work related to DerivedB class 
    } 
} 


int main() 
{ 
    AppSpecificVisitor myVisitor; 

    Base* myBase = // any class in your hierarchy 

    myBase->Visit(&myVisitor); 
} 

正如我在与访问者模式评论说，你可以在功能上增加新的不改变主层次结构（基极 - >派生类型）。您只需定义一个新的访问者实现并为主层次结构中的每个类编写逻辑。在您的示例中，您可以将应用程序特定的逻辑打包到一个对象中，并在派生对象中引用这个更简单的方法。

Answer 2

为什么不使用一组新层次结构来实现特定于应用程序？

class AppBase 
{ 
public: 
    virtual ~AppBase() throw(); 
    virtual void work_with_app() = 0; 
}; 

class Base 
{ 
public: 
    Base(AppBase& app) : m_app(app) {} 
    virtual ~Base() throw(); 
protected: 
    AppBase& m_app; 
}; 

class DerivedA : public Base { DerivedA(AppBase& app) : Base(app) {} }; 

class DerivedB : public Base { DerivedA(AppBase& app) : Base(app) {} }; 

// Application specific implementation : 
class AppLuaSpecific : public AppBase 
{ 
public: 
    void work_with_app() { /* Lua app specific */ } 
}; 

这样，你的第一个层次：Base，DerivedA，DerivedB能生活在不知道有关AppLuaSpecific实现的应用程序特定代码什么。

Answer 3

您可以实现自己的应用程序特定的调度如下（check it live on Coliru）：

#include <iostream> 
#include <typeinfo> 


struct Base { virtual ~Base() {} }; 

struct DerivedA : public Base { }; 

struct DerivedB : public Base { }; 

namespace AppSpecific 
{ 

template<class F> 
void dispatch(const Base& b) 
{ 
    const std::type_info& t = typeid(b); 
    if (t == typeid(DerivedA)) 
     F::doit(static_cast<const DerivedA&>(b)); 
    else if (t == typeid(DerivedB)) 
     F::doit(static_cast<const DerivedB&>(b)); 
} 

struct Foo 
{ 
    static void doit(const DerivedA& da) { std::cout << "Foo(DerivedA)\n"; } 
    static void doit(const DerivedB& db) { std::cout << "Foo(DerivedB)\n"; } 
}; 

struct Bar 
{ 
    static void doit(const DerivedA& da) { std::cout << "Bar(DerivedA)\n"; } 
    static void doit(const DerivedB& db) { std::cout << "Bar(DerivedB)\n"; } 
}; 

} // namespace AppSpecific 

int main() 
{ 
    DerivedA da; 
    DerivedB db; 

    Base& b1 = da; 
    Base& b2 = db; 
    AppSpecific::dispatch<AppSpecific::Foo>(b1); 
    AppSpecific::dispatch<AppSpecific::Foo>(b2); 
    AppSpecific::dispatch<AppSpecific::Bar>(b1); 
    AppSpecific::dispatch<AppSpecific::Bar>(b2); 
}