Há scala-like mixins para C ++?

Question

Scala Mixins

Answer 1

Não, mas ele pode ser falsificado em diferentes graus com modelos:

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, eu não testei isso, a compilá-lo, mas você deve ficar com a ideia.

Answer 2

Alguns aspectos da mixins Scala pode ser satisfeita usando herança múltipla (virtual). Infelizmente, isso muitas vezes introduz mais problemas do que resolve. Além disso, você não pode misturar e combinar superclasses na mosca a la :

val me = new Human with Coder with Musician

Se você realmente, realmente quer verdadeiros mixins, você quase tem que ir com algo parecido com a solução do modelo proposto na resposta por @ Logan Capaldo .

Answer 3

Apenas para reiterar e estender o mencionado no e-mails anteriores deixe-me primeiro dar-lhe um exemplo de como implementar o traço ordenada Scala em C ++ e, em seguida, deixe-me mostrar como você pode misturar-in um número arbitrário de "traços" na instanciação tempo.

Vamos começar primeiro com o traço Ordenado. Se você estiver familiarizado com o Scala SDK você vai ter notado que há um traço Ordenado. Isto é usado para fornecer ordenação total por meio da implementação de um simples "comparar" método. Em C ++, você poderia fazer o mesmo como segue:

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

Então, para dar propriedade de ordenação para uma classe C ++ que você pode fazer o seguinte:

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

Obviamente você pode misturar-in como muitos "traços" como você quer, mas se você fizer desta forma você não pode adicionar ou remover traços em tempo de instanciação. Existe uma solução simples para isso? Tipo-de.

já ouviu falar sobre o C ++ 0x variádica modelos? Isso fornece uma maneira de misturar-in como muitos traços como você quer em tempo de instanciação de modelo.

O truque é simples, basta declarar sua classe anfitrião da seguinte forma:

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

Qual é o problema aqui? Bem, a questão é que não é possível fazer algo parecido com isto:

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

que em alguns casos teria sido útil.

Em qualquer caso, C ++ tem algum mecanismo básico que permite que você imitar alguns aspectos da Mix-ins do Scala. O que não pode fazer, no entanto, está empilhando comportamento.

HTH.