Quali sono i Mixins (come concetto)

Prima di andare in quello che un mix-in, è utile descrivere i problemi che cerca di risolvere. Diciamo che avete un sacco di idee o concetti che si sta tentando di modello. Essi possono essere in qualche modo correlati, ma sono ortogonali per la maggior parte-il che significa che si può stare da soli in modo indipendente. Ora si potrebbe modello di questo attraverso l’ereditarietà e ognuno di quei concetti che derivano da alcuni comuni classe di interfaccia. Quindi è fornire strumenti concreti in derivati di classe che implementa l’interfaccia.

Il problema con questo approccio è che questa struttura non offre alcuna chiara e intuitiva per prendere ciascuna di tali classi concrete e combinarli insieme.

L’idea con mix-ins è quello di fornire un sacco di classi primitive, dove ognuno di essi i modelli di una base ortogonale concetto, e di essere in grado di attaccare insieme per comporre più complesse classi con solo le funzionalità che si desidera-un po ‘ come i lego. Le classi primitive stessi sono destinati ad essere utilizzati come blocchi di costruzione. Questo è estensibile, dal momento che in seguito si possono aggiungere altre classi primitive per la raccolta senza modificare quelli esistenti.

Tornando al C++, una tecnica per farlo è con l’utilizzo di modelli e di eredità. L’idea di base è che si collega questi blocchi di costruzione, offrendo loro tramite il parametro del modello. Quindi catena insieme, ad esempio. via typedef, per formare un nuovo tipo contenente le funzionalità che si desidera.

Prendendo il tuo esempio, diciamo che si desidera aggiungere un ripristino funzionalità. Ecco come potrebbe sembrare:

#include <iostream>
using namespace std;

struct Number
{
  typedef int value_type;
  int n;
  void set(int v) { n = v; }
  int get() const { return n; }
};

template <typename BASE, typename T = typename BASE::value_type>
struct Undoable : public BASE
{
  typedef T value_type;
  T before;
  void set(T v) { before = BASE::get(); BASE::set(v); }
  void undo() { BASE::set(before); }
};

template <typename BASE, typename T = typename BASE::value_type>
struct Redoable : public BASE
{
  typedef T value_type;
  T after;
  void set(T v) { after = v; BASE::set(v); }
  void redo() { BASE::set(after); }
};

typedef Redoable< Undoable<Number> > ReUndoableNumber;

int main()
{
  ReUndoableNumber mynum;
  mynum.set(42); mynum.set(84);
  cout << mynum.get() << '\n';  //84
  mynum.undo();
  cout << mynum.get() << '\n';  //42
  mynum.redo();
  cout << mynum.get() << '\n';  //back to 84
}

Si noterà che ho fatto un paio di modifiche dall’originale:

• Le funzioni virtuali, in verità, non necessaria, perché sappiamo esattamente che cosa il nostro composto per il tipo di classe è a tempo di compilazione.
• Ho aggiunto un default value_type per il secondo modello param per rendere il suo utilizzo meno ingombrante. In questo modo non è necessario digitare <foobar, int> ogni volta che ti infili un pezzo insieme.
• Invece di creare una nuova classe che eredita da i pezzi, un semplice typedef è utilizzato.

Di notare che questo è destinato ad essere un semplice esempio per illustrare il mix-in idea. In modo da non prendere in considerazione casi particolari e divertenti usi. Per esempio, l’esecuzione di un undo senza mai segnare un numero probabilmente non si comportano come ci si potrebbe aspettare.

Come una nota a margine, si potrebbe anche trovare in questo articolo utile.

Mi piace la risposta da greatwolf, ma di offrire un punto di attenzione.

greatwolf ha dichiarato, “Le funzioni virtuali, in verità, non necessaria, perché sappiamo esattamente che cosa il nostro composto per il tipo di classe è a tempo di compilazione.” Purtroppo, si può incorrere in qualche comportamento incoerente se si utilizza l’oggetto polymorphically.

Mi permetta di modificare la funzione principale dal suo esempio:

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!
}  

Facendo il “set” funzione virtuale, il corretto ignorare verrà chiamato e il comportamento incoerente di cui sopra non si verifica.

Questo funziona come un’interfaccia e forse di più, in modo astratto, ma le interfacce sono più facili da ottenere prima volta.

Risolve molti problemi, ma quello che ho trovare in via di sviluppo che viene su un lotto api esterne. immaginate questo.

Si dispone di un database di utenti, il database ha un certo modo di ottenere l’accesso ai suoi dati.
ora immaginate di avere facebook, che ha anche un certo modo di ottenere l’accesso ai dati (api).

in qualsiasi momento la tua applicazione potrebbe essere necessario eseguire utilizzando i dati di facebook o il tuo database. così che cosa dovete fare è creare un’interfaccia che dice “tutto ciò che implementa mi sta per sicuramente hanno i seguenti metodi” ora, è possibile implementare l’interfaccia nelle applicazioni…

perché l’interfaccia promesse che l’implementazione di archivi avrà i metodi dichiarati in loro, sai che ovunque o ogni volta che si utilizza l’interfaccia dell’applicazione, se si passa i dati, si sta andando sempre di avere i metodi per la definizione e quindi avere i dati per lavorare fuori di.

Ci sono molti più livelli di questo modello di lavoro, ma la sostanza è che è un bene perché, dati o altri tali persistenti elementi di diventare una grande parte della vostra applicazione, e se cambiano senza che tu lo sappia, l’applicazione può rompere 🙂

Ecco alcuni pseudo-codice.

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.