在C++私有構造

Question

我想實現的是由

• 一個工廠類工廠模式工廠模式
• 的抽象類與受保護的構造
• 繼承類有私有構造函數和虛擬公共 析構函數。

我想確保

• 沒有其他人比工廠不能創建任何實例
• 如果一個新的繼承類的定義也不會要求對接口類，並已進行任何修改定義的繼承類。 Juts新類實現並添加到工廠類中創建方法。

我也不想爲每個繼承類編寫類似代碼（比如每個被繼承類的靜態工廠方法），並讓未來的開發人員爲工廠連接做很多工作。

即與pseduo代碼

class Factory; 

class Interface 
{ 
    protected: 
     Interface(){/*Do something*/}; 
    public: 
     virtual ~Interface(){/*Do something*/} 
    /*I wish I could do below and it is valid for all inherited 
    classes but friendship is not inherited in C++*/ 
    //friend Interface* Factory::create(Type) 
}; 

class InheritedA:public Interface 
{ 
    private: 
     InheritedA(){/*Do something*/}; 
    public: 
     virtual ~InheritedA(){/*Do something*/} 
    /*I dont want to do below two lines for every inherited class*/ 
    //friend Interface Factory::create(Type) 
    //public: Interface* factoryInheritedA(){return new InheritedA();} 
}; 

class InheritedB:public Interface 
{ 
    private: 
     InheritedB(){/*Do something*/}; 
    public: 
     virtual ~InheritedA(){/*Do something*/} 
}; 

class Factory 
{ 
    static Interface* create(Interface type)  
    { 
      switch(type) 
      { 
      case A: 
       return new InheritedA(); 
      case B: 
       return new InheritedB(); 
      default: 
       //exceptions etc 
      } 
    } 
} 

int main() 
{ 
    Interface* I = Factory::create(A/*or B*/); 
    return 0; 
} 

上面的代碼是我放出來的cloest。任何建議（C++的專業，不同的設計，...）都是值得歡迎的。

Answer 1

你可以有一個模板功能：

template<typename Type> 
std::unique_ptr<Interface> make_interface() { 
    // exceptions etc.. 
} 

template<> 
std::unique_ptr<Interface> make_interface<InheritedA>() { 
    return std::make_unique<InheritedA>(); 
} 

template<> 
std::unique_ptr<Interface> make_interface<InheritedB>() { 
    return std::make_unique<InheritedB>(); 
} 

但我真的沒有看到這一切Javaesque樣板點。更不用說，你真的無緣無故地將編譯時信息（類型）轉換爲運行時信息（通過例外）。

與我只想去：在需要的時候

std::unique_ptr<Interface> ptr_a = std::make_unique<InheritedA>(); 
std::unique_ptr<Interface> ptr_b = std::make_unique<InheritedB>(); 

。

Answer 2

我不認爲這是一個好主意，但這裏有一個方法可以做到這一點。您可以創建一個只能由Factory創建的標籤類型，並使所有構造函數都具有該類型的參數。

class Factory; 

class Tag 
{ 
    Tag() {} 
    friend Factory; 
}; 

class Interface 
{ 
public: 
    Interface(Tag t) {} 
    virtual ~Interface() {} 
}; 

struct Impl1: public Interface 
{ 
    Impl1(Tag t): Interface(t) {} 
}; 

class Factory 
{ 
public: 
    Interface* makeInstance() 
    { 
     return new Impl1(Tag{}); 
    } 
}; 

void foo() 
{ 
    Impl1 i(Tag{}); 
} 

您將在foo()因爲Tag::Tag是民營得到一個編譯錯誤。

Answer 3

使用Factory幾乎不是一個好習慣。我把它和Singleton一起算作反模式。在良好的設計中，classess不關心他們是如何創建的。在你的情況下，當在Factory中使用時，你如何使用自定義分配器創建你的類？在堆棧上？在共享內存中？在內存映射文件中？從緩衝區？到位？這在工廠中確實很難涵蓋，但不要絕望 - 簡單而優雅的解決方案將工廠拋棄！