C++ puis-je créer des dérivées au lieu de la classe basse dépendant des arguments donnés au constructeur unique?

Question

Si j'ai une classe de base avec une classe dérivée, est-il possible de créer des instances comme la classe basse ou dérivée dépendante des arguments passés dans un seul constructeur?

Exemple de code:

//Base Class 
class MyClass { 
public: 
    //All instances created with this constructor 
    MyClass(int param1, int param2) { 
    if (param1 > param2) { //(for example) 
     // TODO - create this object as SubClass instead 
    } else { 
     //normal base class construction 
    } 
    } 
} 

//Derived Class 
class SubClass { 
public: 
    SubClass(int param1, int param2) { 
    //Subclass construction 
    } 

    void function() { 
    //function that only works on subclass objects 
    } 
} 

MyClass object1(1, 2); //should create MyClass object 
MyClass object2(2, 1); //should create SubClass object 

Comme indiqué ci-dessus, lorsqu'une instance de cette classe est créée, je veux que le constructeur soit de fonctionner normalement et de faire la classe, ou (en fonction des valeurs données comme arguments) faites-en une instance de la sous-classe dérivée. Notez qu'il doit être basé sur les valeurs des différents paramètres, pas seulement sur leurs types. Est-il possible de faire cela? Si nécessaire, il serait utile d'avoir une autre classe dérivée pour représenter l'option 'normal' (au lieu d'utiliser la classe de basse pure), tant qu'un seul constructeur doit être utilisé. Si ce n'est pas possible, je peux appeler le constructeur SubClass quand je veux une instance de ceci, mais ce n'est pas idéal car je devrais vérifier lequel devrait être créé à chaque fois que l'on est créé, plutôt que d'avoir un seul contrôle interne au sein du constructeur.

Answer 1

Vous pouvez déléguer la création d'une fonction statique de MyClass:

class SubClass; 

//Base Class 
class MyClass { 
    MyClass(int param1, int param2) { 
    } 
public: 
    static unique_ptr<MyClass> Create(int param1, int param2) { 
    if (param1 > param2) { //(for example) 
     return std::make_unique<SubClass>(param,param2); 
    } else { 
     return std::make_unique<MyClass>(param,param2); 
    } 
    } 
} 

//Derived Class 
class SubClass : public MyClass { 
    SubClass(int param1, int param2) { 
    //Subclass construction 
    } 
public: 

    void function() { 
    //function that only works on subclass objects 
    } 
} 

std::unique_ptr<MyClass> object1 = MyClass::Create(1, 2); //should create MyClass object 
std::unique_ptr<MyClass> object1 = MyClass::Create(2, 1); //should create SubClass object 

Answer 2

Vous devez utiliser un tissu. Il retournera un pointeur vers la classe parente en fonction de vos paramètres. Vous travaillerez avec elle via une interface de votre classe parente. Voir https://en.wikipedia.org/wiki/Abstract_factory_pattern et https://en.wikipedia.org/wiki/Factory_method_pattern