在Python编程中,Mark Lutz提到了术语mixin。我有C/ c++ / c#的背景,以前没有听说过这个术语。什么是mixin?

从这个例子的字里行间(我链接了这个例子,因为它很长),我假设这是一个使用多重继承来扩展类的情况,而不是适当的子类化。这样对吗?

为什么我要这样做,而不是把新功能放到一个子类?就此而言,为什么混合/多重继承方法会比使用组合更好呢?

mixin与多重继承的区别是什么?这只是语义上的问题吗?


当前回答

大致总结一下上面所有的好答案:

                States        /     Methods Concrete Method Abstract Method
Concrete State Class Abstract Class
Abstract State Mixin Interface

其他回答

我认为这里有一些很好的解释,但我想提供另一个角度。

In Scala, you can do mixins as has been described here but what is very interesting is that the mixins are actually 'fused' together to create a new kind of class to inherit from. In essence, you do not inherit from multiple classes/mixins, but rather, generate a new kind of class with all the properties of the mixin to inherit from. This makes sense since Scala is based on the JVM where multiple-inheritance is not currently supported (as of Java 8). This mixin class type, by the way, is a special type called a Trait in Scala.

它在定义类的方式中有所暗示: NewClass用SecondMixin和ThirdMixin扩展了FirstMixin …

我不确定CPython解释器是否做同样的事情(mixin class-composition),但我不会感到惊讶。同样,作为c++背景,我不会将ABC或“接口”称为等同于mixin——它们是类似的概念,但在使用和实现上有所不同。

OP提到他/她从未听说过c++中的mixin,可能是因为它们在c++中被称为奇怪的重复模板模式(CRTP)。另外,@Ciro Santilli提到,mixin在c++中是通过抽象基类实现的。虽然可以使用抽象基类来实现mixin,但这是一种过度使用,因为运行时的虚函数功能可以在编译时使用模板来实现,而不需要在运行时查找虚表。

这里将详细描述CRTP模式

我已经使用下面的模板类将@Ciro Santilli的回答中的python示例转换为c++:

    #include <iostream>
    #include <assert.h>

    template <class T>
    class ComparableMixin {
    public:
        bool operator !=(ComparableMixin &other) {
            return ~(*static_cast<T*>(this) == static_cast<T&>(other));
        }
        bool operator <(ComparableMixin &other) {
            return ((*(this) != other) && (*static_cast<T*>(this) <= static_cast<T&>(other)));
        }
        bool operator >(ComparableMixin &other) {
            return ~(*static_cast<T*>(this) <= static_cast<T&>(other));
        }
        bool operator >=(ComparableMixin &other) {
            return ((*static_cast<T*>(this) == static_cast<T&>(other)) || (*(this) > other));
        }
        protected:
            ComparableMixin() {}
    };

    class Integer: public ComparableMixin<Integer> {
    public:
     Integer(int i) {
         this->i = i;
     }
     int i;
     bool operator <=(Integer &other) {
         return (this->i <= other.i);
     }
     bool operator ==(Integer &other) {
         return (this->i == other.i);
     }
    };

int main() {

    Integer i(0) ;
    Integer j(1) ;
    //ComparableMixin<Integer> c; // this will cause compilation error because constructor is protected.
    assert (i < j );
    assert (i != j);
    assert (j >  i);
    assert (j >= i);

    return 0;
}

编辑:在ComparableMixin中添加了受保护的构造函数,这样它只能被继承而不能被实例化。更新了示例,以显示在创建ComparableMixin对象时protected构造函数将如何导致编译错误。

首先,您应该注意,mixin只存在于多继承语言中。你不能在Java或c#中做mixin。

基本上,mixin是一个独立的基类型,为子类提供有限的功能和多态共振。如果你在用c#思考,考虑一个你不需要实际实现的接口,因为它已经实现了;你只是继承了它,并从它的功能中受益。

mixin的范围通常很窄,不需要扩展。

[编辑——至于为什么:]

既然你问了,我想我该解释一下原因。最大的好处是你不需要自己一遍又一遍地做。在c#中,mixin最大的好处可能来自于处置模式。无论何时实现IDisposable,您几乎总是希望遵循相同的模式,但最终要编写和重写相同的基本代码,只是略有变化。如果有一个可扩展的处置mixin,您可以节省大量额外的输入。

[编辑2 -回答你的其他问题]

mixin与多重继承的区别是什么?这只是语义上的问题吗?

是的。mixin和标准多重继承之间的区别只是语义上的问题;具有多重继承的类可以利用mixin作为多重继承的一部分。

mixin的目的是创建一个可以通过继承“混合”到任何其他类型的类型,而不影响继承类型,同时仍然为该类型提供一些有益的功能。

同样,考虑一个已经实现的接口。

我个人不使用mixins,因为我主要是用一种不支持mixins的语言开发的,所以我很难想出一个像样的例子来为您提供“啊哈!”的时刻。但我会再试一次。我将使用一个人为设计的示例——大多数语言已经以某种方式提供了该特性——但希望这将解释mixin应该如何创建和使用。是:

Suppose you have a type that you want to be able to serialize to and from XML. You want the type to provide a "ToXML" method that returns a string containing an XML fragment with the data values of the type, and a "FromXML" that allows the type to reconstruct its data values from an XML fragment in a string. Again, this is a contrived example, so perhaps you use a file stream, or an XML Writer class from your language's runtime library... whatever. The point is that you want to serialize your object to XML and get a new object back from XML.

本例中另一个重要的一点是,您希望以通用的方式执行此操作。你不希望为你想要序列化的每一个类型都实现一个“ToXML”和“FromXML”方法,你需要一些通用的方法来确保你的类型能够做到这一点,并且它只是工作。您希望代码重用。

如果您的语言支持它,您可以创建XmlSerializable mixin来完成您的工作。这种类型将实现ToXML和FromXML方法。它将使用一些对示例不重要的机制,能够从混合在其中的任何类型收集所有必要的数据,以构建由ToXML返回的XML片段,并且在调用FromXML时同样能够恢复该数据。

和. .就是这样。要使用它,您需要从XmlSerializable继承任何需要序列化为XML的类型。每当需要序列化或反序列化该类型时,只需调用ToXML或FromXML即可。事实上,由于XmlSerializable是一种成熟的多态类型,因此可以想象,您可以构建一个文档序列化器,它对原始类型一无所知,只接受一个XmlSerializable类型数组。

现在想象一下将这个场景用于其他事情,比如创建一个mixin,以确保每个混合它的类都记录每个方法调用,或者为混合它的类型提供事务性的mixin。这样的例子不胜枚举。

如果您只是将mixin视为一个小型的基本类型,用于在不影响类型的情况下向类型添加少量功能,那么您就很好了。

希望。:)

也许ruby中的一个例子会有所帮助:

你可以包含mixin Comparable并定义一个函数"<=>(other)", mixin提供了所有这些函数:

<(other)
>(other)
==(other)
<=(other)
>=(other)
between?(other)

它通过调用<=>(other)并返回正确的结果来实现这一点。

"instance <=> other"如果两个对象相等则返回0,如果instance大于other则返回小于0,如果other大于0则返回大于0。

我读到你有c#背景。因此,一个好的起点可能是。net的mixin实现。

你可能想在http://remix.codeplex.com/上查看codeplex项目

请观看lang.net Symposium链接以获得概述。codeplex页面上还有更多的文档。

问候 斯特凡