Y at-il mixins comme scala pour C ++?

Question

Scala Mixins

Answer 1

Non, mais il peut être falsifiée à des degrés divers avec les modèles:

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

Pour être tout à fait honnête, je l'ai ai pas testé en compilant, mais vous devriez avoir l'idée.

Answer 2

Certains aspects de mixins Scala peuvent être satisfaites par l'héritage multiple (virtuel). Malheureusement, cela présente souvent plus de problèmes qu'elle en résout. En outre, vous ne pouvez pas mélanger et faire correspondre superclasses à la volée à la :

val me = new Human with Coder with Musician

Si vous avez vraiment, vraiment voulez vrai mixins, vous avez presque d'aller avec quelque chose comme la solution du modèle proposé dans la réponse par @ Logan Capaldo .

Answer 3

Il suffit de rappeler et d'étendre ce que mentionné dans les courriels précédents vous me donnez d'abord laisser un exemple de la façon de mettre en œuvre la Scala trait Ordonné en C ++ et laissez-moi montrer comment vous pouvez mélanger dans un nombre arbitraire de « traits » à l'instanciation temps.

Commençons d'abord avec le trait Ordonné. Si vous êtes familier avec le SDK Scala vous aurez remarqué qu'il ya un trait Ordonné. Il est utilisé pour fournir la commande totale au moyen de mettre en œuvre une méthode simple « comparer ». En C ++, vous pouvez faire la même chose comme suit:

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

Alors, pour donner la propriété à une commande de classe C ++, vous pouvez faire ce qui suit:

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

Il est évident que vous pouvez mélanger en autant de « traits » que vous voulez, mais si vous le faites de cette façon vous ne pouvez pas ajouter ou supprimer des traits au moment de l'instanciation. Y at-il une solution simple pour cela? Type-de.

ont entendu parler du C ++ 0x modèles variadique? Cela fournit un moyen de mélange en autant de traits que vous voulez au moment de l'instanciation de modèle.

L'astuce est simple, simplement déclarer votre classe hôte comme suit:

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

Quelle est la capture ici? Eh bien, la question est qu'il est impossible de faire quelque chose comme ceci:

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

Ce qui, dans certains cas, aurait été à portée de main.

Dans tous les cas, C ++ a un mécanisme de base qui vous permettent d'imiter certains aspects de Mix-ins Scala. Ce qu'il ne peut pas faire, cependant, est un comportement d'empilement.

HTH.