C++設計查詢

Question

我正在設計一個C++框架，該框架應該提供基本功能並充當其他派生系統的接口。

#include <stdio.h> 

class Module 
{ 
    public: 
    virtual void print() 
    { 
     printf("Inside print of Module\n"); 
    } 
}; 
class ModuleAlpha : public Module 
{ 
    public: 
    void print() 
    { 
     printf("Inside print of ModuleAlpha\n"); 
    } 
    void module_alpha_function() /* local function of this class */ 
    { 
     printf("Inside module_alpha_function\n"); 
    } 
}; 
class System 
{ 
    public: 
    virtual void create_module(){} 
    protected: 
    class Module * module_obj; 
}; 
class SystemAlpha: public System 
{ 
    public: 
    void create_module() 
    { 
     module_obj = new ModuleAlpha(); 
     module_obj->print(); // virtual function, so its fine. 

     /* to call module_alpha_function, dynamic_cast is required, 
     * Is this a good practice or there is some better way to design such a system */ 
     ModuleAlpha * module_alpha_obj = dynamic_cast<ModuleAlpha*>(module_obj); 
     module_alpha_obj->module_alpha_function(); 
    } 
}; 

main() 
{ 
    System * system_obj = new SystemAlpha(); 
    system_obj->create_module(); 
} 

編輯代碼更加合乎邏輯，它立即編譯。問題是，有沒有更好的方法來設計這樣的系統，或者dynamic_cast是唯一的解決方案。另外，如果有更多派生模塊，那麼對於類型轉換，基本模塊類中需要一些智能。

Answer 1

如果Derived是Base的唯一具體實例，則可以使用static_cast代替。

就我個人而言，我定義了一個函數，如MyCast爲每個專門的類。我定義了四個重載的變體，以便我可以向下轉換const和非const指針和引用。例如：

inline Derived  * MyCast(Base  * x) { return static_cast<Derived *>  (x); } 
    inline Derived const * MyCast(Base const * x) { return static_cast<Derived const *>(x); } 
    inline Derived  & MyCast(Base  & x) { return static_cast<Derived &>  (x); } 
    inline Derived const & MyCast(Base const & x) { return static_cast<Derived const &>(x); } 

同樣適用於Derived2和Base2。

擁有全部四個優點的最大好處是你不會偶然改變const，並且無論你有指針還是引用，你都可以使用相同的構造。

當然，你可以用宏替換static_cast，並在調試模式下使用dynamic_cast和static_cast是釋放模式。

此外，上面的代碼可以很容易地包裝到一個宏中，使批量定義函數變得容易。

地使用這種模式，然後你可以實現你的代碼爲：

class Derived : public Base 
{ 
public: 
    virtual void func2() 
    { 
    base2_obj = new Derived2(); 
    } 
    void DerivedFunc() 
    { 
    MyCast(base2_obj)->Derived2Func(); 
    } 
} 

Answer 2

設計變得乾淨多了，如果Base不包含base_obj對象，而是獲得通過虛擬方法的引用。 Derived應包含Derived2對象，如：

class Base 
{ 
    public: 
     virtual void func1(); 
    private: 
     class Base2; 
     virtual Base2& get_base2(); 
}; 
class Derived : public Base 
{ 
     Derived2 derived2; 
    public: 
     Base2& get_base2() { return derived2; } 
     void DerivedFunc() 
     { 
       derived2->Derived2Func(); 
     } 
} 

如果你擔心性能，在Base構造函數傳遞引用。

Answer 3

我把你的代碼與許多編譯錯誤，並試圖簡化它。這是你想要達到的目標嗎？它會編譯。

class Base2 { 
    public: 
    virtual void Derived2Func(){ 
    } 
}; 

Base2* fnToInstantiateABase2(); 

class Base { 
    public: 
    Base() : base2_obj(fnToInstantiateABase2()) { 
    } 
    virtual void DerivedFunc() { 
    } 
    protected: 
    Base2* base2_obj; 
}; 
class Derived : public Base { 
    public: 
    void DerivedFunc() { 
     base2_obj->Derived2Func(); // not possible as base2_obj is of type Base2 
    } 
}; 


class Derived2 : public Base2 { 
    public: 
    void Derived2Func() { 
    } 
}; 


void test() { 
    Base * base_obj = new Derived(); 
    base_obj->DerivedFunc(); 
} 

Base2* fnToInstantiateABase2() { 
    return new Derived2(); 
}