Interface fluide et héritage en C++

Question

Je voudrais construire une classe de base (abstraite) (appelons-la type::base) avec une fonctionnalité courante et une interface fluide, le problème auquel je fais face est le type de retour de toutes ces méthodes

class base { 
    public: 
     base(); 
     virtual ~base(); 

     base& with_foo(); 
     base& with_bar(); 
    protected: 
     // whatever... 
    }; 

maintenant, je pourrais faire des sous-types, par exemple:

class my_type : public base { 
    public: 
     myType();   
     // more methods... 
    }; 

Le problème vient lorsque vous utilisez ces sous-types comme ceci:

my_type build_my_type() 
{ 
    return my_type().with_foo().with_bar(); 
} 

Ceci ne sera pas compilé car nous retournons la base au lieu de my_type.

Je sais que je pouvais:

my_type build_my_type() 
{ 
    my_type ret; 
    ret.with_foo().with_bar(); 

    return ret; 
} 

Mais je pensais comment puis-je mettre en œuvre, et je ne l'ai pas trouvé des idées valables, une suggestion?

Answer 1

Ce problème de "perdre le type" peut être résolu avec des modèles - mais c'est plutôt compliqué.

Par exemple.

class Pizza 
{ 
    string topping; 
public: 
    virtual double price() const; 
}; 

template <class T, class Base> 
class FluentPizza : public Base 
{ 
    T* withAnchovies() { ... some implementation ... }; 
}; 

class RectPizza : public FluentPizza<RectPizza, Pizza> 
{ 
    double price() const { return length*width; :) } 
}; 

class SquarePizza : public FluentPizza<SquarePizza, RectPizza> 
{ 
    ... something else ... 
}; 

Vous pouvez alors écrire

SquarePizza* p=(new SquarePizza)->withAnchovies(); 

Le modèle est qu'au lieu de

class T : public B 

vous écrire

class T : public Fluent<T, B> 

Une autre approche pourrait être de ne pas utiliser interface fluide sur les objets, mais sur les pointeurs au lieu:

class Pizza { ... }; 
class RectPizza { ... }; 
class SquarePizza { ... whatever you might imagine ... }; 

template <class T> 
class FluentPizzaPtr 
{ 
    T* pizza; 
public: 
    FluentPizzaPtr withAnchovies() { 
    pizza->addAnchovies(); // a nonfluent method 
    return *this; 
    } 
}; 

Utilisez comme ceci:

FluentPizzaPtr<SquarePizza> squarePizzaFactory() { ... } 

FluentPizzaPtr<SquarePizza> myPizza=squarePizzaFactory().withAnchovies(); 

Answer 2

La façon dont je le ferais en C#, et je crois qu'il travaillerait en C++ aussi est de fournir une implémentation par défaut pour with_foo() et with_bar() ... Pardonnez mon C#, mais:

class base { 
    virtual base with_foo() 
    { throw new NotImplementedException(); } 
    virtual base with_bar(); 
    { throw new NotImplementedException(); } 
} 

Answer 3

En C++ vous devriez conserver des pointeurs ou des références plutôt que des valeurs. Aussi, vous pourriez vouloir expliquer ce que vous entendez par "interfaces fluentes".

Answer 4

Une solution fonctionnerait comme ceci:

return *static_cast<my_type*>(&my_type().with_foo().with_bar()); 

L'utilisation static_cast dit essentiellement le compilateur «Je sais ce que je fais ici.

Answer 5

Vous devriez retournerez références/pointeurs, et vous ne devriez pas besoin de garder les informations de type.

class base { 
    public: 
    base(); 
    virtual ~base(); 

    base &with_foo(); 
    base &with_bar(); 
    protected: 
    // whatever... 
}; 

class my_type : public base { 
    public: 
    my_type();   
    // more methods... 
}; 

base *build_my_type() 
{ 
    return &new my_type()->with_foo().with_bar(); 
} 

Vous avez déjà un destructeur virtuel. Vraisemblablement, vous avez d'autres fonctions virtuelles.Accédez à tout via le type de base et les fonctions virtuelles qui y sont déclarées.