ci sono mixins Scala-come per C ++?

Question

Scala Mixin

Answer 1

No, ma può essere simulato in varia misura con i modelli:

template<typename AbsIterator> 
class RichIterator : public AbsIterator {
public:
   template<typename FuncType>
   void foreach(FuncType f) { while( hasNext() ) f( next() ); }
};

class StringIterator {
  std::string m_s;
  int i;
public:
  typedef char T;
  StringIterator() : m_s(), i(0) {} // Unfortunately need this, or 
                                    // else RichIterator
                                    // gets way more complicated
  StringIterator(const std::string &s) : m_s(s), i(0) {}
  void swap(StringIterator& other) {
     m_s.swap(other.m_s);
     std::swap(i, other.i);
  }
  void reset_str(const std::string& s) {
     StringIterator(s).swap(*this);
  }
  bool hasNext() { return i < m_s.length(); }
  char next() { return m_s[i++]; }
};

template<typename Outputable>
void println(const Outputable& o) {
   std::cout << o << std::endl;
}

int main(int argc, char **argv) {
  typedef RichIterator<StringIterator> Iter;
  Iter iter;
  iter.reset_str(argv[1]);
  iter.foreach(&println<Iter::T>);
}

Per essere completamente onesto, ho non ho ancora testato questo compilarlo, ma si dovrebbe ottenere l'idea.

Answer 2

Alcuni aspetti di mixins Scala possono essere soddisfatti utilizzando l'ereditarietà multipla (virtuale). Purtroppo, questo spesso introduce più problemi di quanti ne risolva. Inoltre, non è possibile combinare superclassi al volo a la :

val me = new Human with Coder with Musician

Se davvero, davvero volete veri mixins, è quasi dovuto andare con qualcosa di simile alla soluzione di modello proposto nella risposta da @ Logan Capaldo .

Answer 3

Proprio per ribadire ed estendere quanto già detto in messaggi di posta elettronica precedenti mi permetta prima di darvi un esempio di come implementare il tratto ordinato Scala di C ++ e poi mi permetta di mostrare come si può mescolare in un numero arbitrario di "tratti" a istanziazione tempo.

Partiamo prima con il tratto ordinato. Se si ha familiarità con la Scala SDK avrete notato che c'è un tratto ordinato. Questo è utilizzato per fornire ordinamento totale mediante l'attuazione di un metodo semplice "confrontare". In C ++, si potrebbe fare lo stesso nel seguente modo:

template <typename T>
class Ordered {
public:
    virtual int32_t compare(const T& that) = 0;
    bool operator >(const T& that) {return this->compare(that) == 1; }
    bool operator >=(const T& that) {return this->compare(that) >= 0; }

    bool operator ==(const T& that) { return this->compare(that) == 0; }

    bool operator <=(const T& that) {return this->compare(that) <= 0; }
    bool operator <(const T& that) {return this->compare(that) == -1; }
};

Quindi, per dare l'ordinazione di proprietà a una classe che si può fare quanto segue C ++:

class MyOrderedType : public Ordered<MyOrderedType> {
public:
  // Your ctor/dtors, methods
public:
  int compare(const MyOrderedType& that);
};

Ovviamente il maggior numero di "tratti" si possono mescolare-in come si vuole, ma se lo fai in questo modo non è possibile aggiungere o rimuovere i tratti al momento dell'istanza. C'è una soluzione semplice per questo? Tipo-di.

Avete sentito parlare dei modelli variadic C ++ 0x? Questo fornisce un modo di mescolare-in come molti tratti come si desidera al momento istanziazione di template.

Il trucco è semplice, basta dichiarare la classe host come segue:

template <typename... MIXINS>
class Host : public MIXINS... {
 // Your implementation
};

Qual è il fermo qui? Beh, il problema è che non è possibile fare qualcosa di simile:

template <typename... MIXINS>
class Host : public MIXINS<HOST>... {
    // Your implementation
};

che in alcuni casi sarebbe stato utile.

In ogni caso, C ++ ha qualche meccanismo di base che consentono di emulare alcuni aspetti del mix-ins di Scala. Quello che non può fare, però, è impilabile comportamento.

HTH.