是否有C ++阶状混入？

Question

Scala中混入

Answer 1

没有，但它也可以伪造与模板不同程度：

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

要完全诚实的，我没有通过编译测试它，但你应该明白我的意思。

Answer 2

Scala中混入的某些方面可以使用多个（虚拟）继承来满足。不幸的是，这往往引入了更多的问题比它解决的。此外，您不能混用，并在飞行中的一拉的匹配超：

val me = new Human with Coder with Musician

如果你真的，的真正的想真正的混入，你几乎必须通过@的洛根CAPALDO 。

Answer 3

只是重申和扩大以前的电子邮件什么提到让我先给你如何实现Scala的有序特质在C ++中，然后让我告诉你如何能混合式的“特征”任意数量的例子在实例时间。

首先我们先从有序特质。如果您熟悉Scala的SDK，你会注意到，有一个有序的特点。这是用来通过执行一个简单的“比较”方法的装置，以提供整体排序。在C ++中，可以按如下方式执行相同的：

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

然后，为了给排序特性到C ++类可以执行以下操作：

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

很明显，你可以混合在尽可能多的“特征”，只要你想，但如果你做这样你不能在实例化时添加或删除的特征。对此有一个简单的解决方案？样-的。

有没有听说过的的C ++ 0x可变参数模板？这提供混合，在尽可能多的特质，只要你想在模板实例化时间的方法。

诀窍是简单，只需声明主机类，如下所示：

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

什么是抓吗？那么，问题是，它是不可能做这样的事情：

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

在某些情况下会一直得心应手。

在任何情况下，C ++有一些基本的机制，使您能够模拟Scala的混合插件的某些方面。它不能做什么，但是，堆叠行为。

HTH。