¿Hay mixins scala-como para C ++?

Question

Scala Mixins

Answer 1

No, pero puede ser falsificada en diversos grados con plantillas:

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>);
}

Para ser totalmente honesto, he no han probado este compilándolo, pero debe hacerse una idea.

Answer 2

Algunos aspectos de mixins Scala pueden satisfacerse utilizando herencia múltiple (virtual). Por desgracia, esto a menudo se presenta más problemas de los que resuelve. Además, no se puede mezclar y combinar superclases sobre la marcha a la

val me = new Human with Coder with Musician

Si realmente, realmente quiere verdaderos mixins, casi se tiene que ir con algo así como la solución de la plantilla propuesta en la respuesta por @ Logan Capaldo .

Answer 3

Sólo para reiterar y ampliar lo mencionado en los correos electrónicos anteriores en primer lugar quisiera darle un ejemplo de cómo implementar la característica ordenada Scala en C ++ y luego déjame mostrar cómo se puede mezclar en un número arbitrario de "rasgos" en instanciación tiempo.

Vamos a empezar primero con el rasgo ordenada. Si está familiarizado con el SDK Scala se le han dado cuenta de que hay un rasgo ordenada. Esto se utiliza para proporcionar ordenación total por medio de la implementación de un método simple de "comparar". En C ++, se puede hacer lo mismo de la siguiente manera:

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

A continuación, para dar ordenar propiedad a una clase de C ++ se puede hacer lo siguiente:

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

Obviamente se puede mezclar en el mismo número "rasgos" si lo desea, pero si lo hace de esta manera no se puede agregar o quitar características en tiempo de creación de instancias. ¿Hay una solución simple para esto? Kind-de.

¿Ha oído hablar de las plantillas variadic C ++ 0x? Esto proporciona una manera de mezclar-en tantos rasgos como desee en el momento de instancias de plantilla.

El truco es sencillo, basta con declarar una clase de acogida de la siguiente manera:

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

¿Cuál es el truco aquí? Bueno, la cuestión es que no es posible hacer algo como esto:

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

Lo que en algunos casos habría sido útil.

En cualquier caso, C ++ tiene algún mecanismo básico que le permiten emular algunos aspectos de ingredientes extra de Scala. Lo que no puede hacer, sin embargo, está apilado comportamiento.

HTH.