C++ 有类似 scala 的 mixin 吗？

Question

Scala 混合

Answer 1

Scala mixin 的某些方面可以使用多重（虚拟）继承来满足。 不幸的是，这往往带来的问题多于它解决的问题。 另外，你不能即时混合和匹配超类a la：

val me = new Human with Coder with Musician

如果你真的，真的想要真正的混合，你几乎必须使用类似模板解决方案的东西@Logan Capaldo 在答案中提出。

Answer 2

为了重申和扩展之前电子邮件中提到的内容，我首先给您一个如何在 C++ 中实现 Scala Ordered 特征的示例，然后让我展示如何在实例化时混合任意数量的“特征”。

让我们首先从 Ordered 特征开始。 如果您熟悉 Scala SDK，您会注意到有一个 Ordered 特征。 这用于通过实现简单的“比较”方法来提供总排序。 在 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);
};

显然，您可以根据需要混合任意数量的“特征”，但如果您这样做，则可以' t 在实例化时添加或删除特征。 有一个简单的解决方案吗？ 有点儿。

听说过 C++0x 可变参数模板吗？ 这提供了一种在模板实例化时混合所需数量的特征的方法。

技巧很简单，只需按如下方式声明您的主机类：

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

这里有什么问题？ 好吧，问题是不可能做这样的事情：

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

在某些情况下这会很方便。

无论如何，C++ 都有一些基本机制可以让您模拟 Scala Mix-ins 的某些方面。 然而，它不能做的是堆叠行为。

HTH。

Answer 3

不，但它可以用模板进行不同程度的伪造：

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

说实话，我还没有通过编译来测试它，但你应该明白这个想法。