Qu'est-ce que les Mixins (en tant que concept)

un mixin est une classe conçue pour fournir des fonctionnalités à une autre classe, normalement par l'intermédiaire d'une classe spécifiée qui fournit les fonctionnalités de base dont la fonctionnalité a besoin. Par exemple, considérez votre exemple:

Le mixin dans ce cas fournit la fonctionnalité de défaire l'opération définie d'une classe de valeur. Cette qualité est basée sur la fonctionnalité get/set fournie par une classe paramétrée (la classe Number , dans votre exemple).

un Autre exemple (Extrait de " Mixin base de la programmation en C++ " ):

template <class Graph>
class Counting: public Graph {
  int nodes_visited, edges_visited;
public:
  Counting() : nodes_visited(0), edges_visited(0), Graph() { }
  node succ_node (node v) {
    nodes_visited++;
    return Graph::succ_node(v);
  }
  edge succ_edge (edge e) {
    edges_visited++;
    return Graph::succ_edge(e);
  }
... 
};

dans cet exemple, le mixin fournit la fonctionnalité de Counting vertices , étant donné une classe de graphe qui effectue des opérations trasversales.

généralement, en C++, les mixins sont implémentés par le CRTP idiom. Ce fil pourrait être une bonne lecture sur un mixin implementation in C++: Qu'est-ce que c++ Mixin-Style?

voici un exemple de mixin qui tire profit de l'idiome du CRTP (merci à @Simple):

#include <cassert>
#ifndef NDEBUG
#include <typeinfo>
#endif

class shape
{
public:
    shape* clone() const
    {
        shape* const p = do_clone();
        assert(p && "do_clone must not return a null pointer");
        assert(
            typeid(*p) == typeid(*this)
            && "do_clone must return a pointer to an object of the same type"
        );
        return p;
    }

private:
    virtual shape* do_clone() const = 0;
};

template<class D>
class cloneable_shape : public shape
{
private:
    virtual shape* do_clone() const
    {
        return new D(static_cast<D&>(*this));
    }
};

class triangle : public cloneable_shape<triangle>
{
};

class square : public cloneable_shape<square>
{
};

ce mixin fournit la fonctionnalité de copie hétérogène à un ensemble (hiérarchie) de classes de formes.

j'aime la réponse de greatwolf, mais je voudrais faire une mise en garde.

, a déclaré greatwolf, " les fonctions virtuelles ne sont vraiment pas nécessaires ici parce que nous savons exactement quel est notre type de classe composé au moment de la compilation."Malheureusement, vous pouvez rencontrer un comportement incohérent si vous utilisez votre objet polymorphiquement.

permettez-moi de modifier la fonction principale de son exemple:

int main()
{
  ReUndoableNumber mynum;
  Undoable<Number>* myUndoableNumPtr = &mynum;

  mynum.set(42);                // Uses ReUndoableNumber::set
  myUndoableNumPtr->set(84);    // Uses Undoable<Number>::set (ReUndoableNumber::after not set!)
  cout << mynum.get() << '\n';  // 84
  mynum.undo();
  cout << mynum.get() << '\n';  // 42
  mynum.redo();
  cout << mynum.get() << '\n';  // OOPS! Still 42!
}  

en faisant le " jeu" fonction virtuelle, le bon correcteur et le comportement incohérent ci-dessus ne se produira pas.

les Mixines en C++ sont exprimées en utilisant le curieusement récurrent Pattern (CRTP). Ce post est une excellente répartition de ce qu'ils fournissent sur les autres techniques de réutilisation... polymorphisme dans le temps de compilation.

cela fonctionne comme une interface et peut-être plus comme un abstrait, mais les interfaces sont plus faciles à obtenir pour la première fois.

il aborde de nombreuses questions, mais un que je trouve dans le développement qui vient beaucoup est apis externes. imaginer cela.

Vous avez une base de données d'utilisateurs, cette base de données a une certaine façon d'obtenir l'accès à ses données. maintenant, imaginez que vous avez facebook, qui a aussi une certaine façon d'obtenir l'accès à ses données (api).

à tout moment votre application peut avoir besoin d'exécuter en utilisant des données de facebook ou de votre base de données. donc, ce que vous faites est de créer une interface qui dit "tout ce qui me met en œuvre va certainement avoir les méthodes suivantes" maintenant, vous pouvez mettre en œuvre cette interface dans votre application...

parce qu'une interface promet que les dépôts de mise en œuvre auront les méthodes déclarées dans eux, vous savez que partout ou chaque fois que vous utilisez cette interface dans votre application, si vous commutez les données, il va toujours avoir les méthodes que vous définissez et donc avoir des données pour travailler hors.

il y a beaucoup plus de couches à ce modèle de travail, mais l'essence est qu'il est bon parce que les données ou d'autres éléments persistants deviennent une grande partie de votre application, et si elles changent sans que vous le sachiez, votre application peut casser :)

voici un pseudo code.

interface IUserRepository
{
    User GetUser();
}

class DatabaseUserRepository : IUserRepository
{
    public User GetUser()
    {
        // Implement code for database
    }
}

class FacebookUserRepository : IUserRepository
{
    public User GetUser()
    {
        // Implement code for facebook
    }
}

class MyApplication
{
    private User user;

    MyApplication( IUserRepository repo )
    {
        user = repo;
    }
}

// your application can now trust that user declared in private scope to your application, will have access to a GetUser method, because if it isn't the interface will flag an error.

pour comprendre le concept oubliez les cours un instant. Pense que (la plus populaire) de JavaScript. Où les objets sont des tableaux dynamiques de méthodes et de propriétés. Appelable par leur nom comme symbole ou comme chaîne littérale. Comment mettriez-vous cela en C++ standard en 2018? pas facilement . Mais c'est le cœur du concept. En JavaScript on peut ajouter et supprimer (alias mix-in) quand et quoi que l'on souhaite. Très important: aucun héritage de classe.

maintenant en C++. Standard c++ a tout ce dont vous avez besoin, n'aide pas comme une déclaration ici. Évidemment, je n'écrirai pas de langage de script pour implémenter mix-in en utilisant C++.

Oui, c'est un bon article , mais pour l'inspiration. Le CRTP n'est pas une panacée. Et aussi la soi-disant approche académique est ici , également (en essence) CRTP basé.

avant de voter cette réponse peut-être considérer mon p. O. C. code sur la case :)