шаблона дизайна для следующей ситуации

Question

У меня есть некоторый код, как:

class Base { 
    virtual bool acceptsData(char*) = 0; 
}; 

class Derived1 : public Base { 
    virtual bool acceptsData(char*) { /* do something */ } 
}; 

class Derived2 : public Base { 
    virtual bool acceptsData(char*) { /* do something else */} 
} 

Base* createStuff(char* data) 
{ 
    Base* d1 = new Derived1(); 
    if(d1->acceptsData(data)) 
    { 
      return d1; 
    } 
    delete d1; 

    Base* d2 = new Derived2(); 
    if(d2->acceptsData(data)) 
    { 
      return d2; 
    } 
    delete d2; 
    // and more ... 
} 
// .... somewhere later 
int main() 
{ 
    Base* Aclass = createStuff("abc"); 
} 

Я хотел бы избавиться от этой долгой if() ... конструкции, а также использовать некоторые более обобщенные модели, но я до сих пор не сделал менеджер придумайте что-нибудь полезное. Есть ли лучший способ сделать это?

Answer 1

Если вы хотите факторизовать код, у вас есть несколько производных классов, вы можете использовать что-то вроде следующего:

namespace detail 
{ 
    template <typename T> std::unique_ptr<Base> make_base(const char* data) 
    { 
     std::unique_ptr<Base> base = std::make_unique<T>(); 
     if (base->acceptsData(data)) { 
      return base; 
     } 
     return nullptr; 
    } 

    template <typename... Ts> std::unique_ptr<Base> createStuff(const char* data) 
    { 
     std::function<std::unique_ptr<Base>(const char*)> fs[] = { make_base<Ts>... }; 

     for(auto& f : fs) { 
      auto base = f(data); 
      if(base) { 
       return base; 
      } 
     } 
     return nullptr; 
    } 
} 

Base* createStuff(const char* data) { 
    return detail::createStuff<Derived1, Derived2/* and other Derived classes*/>(data).release(); 
} 

Live example.

Answer 2

Вы создаете свои объекты. Factory или Builder - подходящие шаблоны для вас.

Answer 3

Что может удовлетворить ваши требования, так это то, что виртуальные конструкторы создают шаблон. Это то, на что это похоже ...

#include <iostream> 
#include <string>  
#include <vector> 
using namespace std; 
class Base { 
    Base* b; 
    // suppress the usual constructors 
    Base(Base&); 
    Base operator=(Base&); 
protected: 
    Base() { b = 0; }; 
public: 
    virtual void Print() { b->Print(); }  
    virtual ~Base() {  
     if (b) {    
      delete b; 
     }  
    } 
    Base(string type); 
}; 
class Derived1 : public Base { 
    Derived1(Derived1&); 
    Derived1 operator=(Derived1&); 
    Derived1() {} 
    friend class Base; 
public: 
    void Print() { cout << "Derived1::Print()" << endl; } 
    ~Derived1() { } 
}; 
class Derived2 : public Base { 
    Derived2(Derived2&); 
    Derived2 operator=(Derived2&); 
    Derived2() {} 
    friend class Base; 
public: 
    void Print() { cout << "Derived2::Print()" << endl; } 
    ~Derived2() { } 
}; 
Base::Base(string type) { 
    if (type == "Derived1") 
     b = new Derived1; 
    else if (type == "Derived2") 
     b = new Derived2; 
} 

int main() { 
    vector<Base*> bases; 
    cout << "virtual constructor calls:" << endl; 
    bases.push_back(new Base("Derived2")); 
    bases.push_back(new Base("Derived1")); 
    bases.push_back(new Base("Derived1")); 
    bases.push_back(new Base("Derived2")); 

    for (int i = 0; i < bases.size(); i++) { 
     bases[i]->Print();  
    } 

    cout << "destructor calls:" << endl; 
    for (int j = 0; j < bases.size(); j++) { 
     delete bases[j];   
    } 

    // system("pause"); 
    return 0; 
}