混型

混型即混合多个类，以产生表示混合了所有类型的类。C++多重继承的目的是为了使用混型，但多重继承使得代码量越来越多，更灵活的方式是使用参数化类型组合特性——继承泛型参数，这样在添加泛型的同时达到继承泛型的特性的目的。

C++的混型
下面的实例可以为Basic添加时间戳TimeStamp和Id属性。

#include<iostream>
#include<time.h>
#include<string>
using namespace std;

template<class T>
class TimeStamp :public T {
private:
	time_t timeStamp;
public:
	TimeStamp() { timeStamp = time(0); }
	time_t getTime() { return timeStamp; }
};

template<class T>
class Id :public T {
private:
	int id;
	static int counter;
public:
	Id() { id = counter++; }
	int getId() { return id; }
};
template<class T>int Id<T>::counter = 0;

class Basic {
private:
	string name;
public:
	Basic() { name = "name"; }
	string getName() { return name; }
};


int main() {
	TimeStamp<Id<Basic>> mix;
	cout << "name:" << mix.getName() << endl
		<< "id:" << mix.getId() << endl
		<< "time:" << mix.getTime();
}

装饰器模式实现混型

接口和代理模式实现混型
C++可以记住模板类，但是Java由于擦除会忘记模板类类型，因此上述方法通过继承泛型参数添加的方法不可用。
Mix类继承自Basic同时实现了TimeStamp和Id接口，同时还具有相应实例的成员，并将成员方法包装在混型方法中，所以包含了基类的所有特性（成员与方法）。

interface TimeStamp{
    Time getTimeStamp();
}
interface Id{
    int getId();
}
interface Basic{
    String getName();
}

class TimpStampImp implements TimeStamp{
    private Time timeStamp;
    public TimpStampImp() { this.timeStamp = new Time(0); }
    public Time getTimeStamp() { return timeStamp; }
}

class IdImp implements Id{
    private static int counter=1;
    private int id=counter++;
    public int getId(){return id;}
}

class BasicImp implements Basic{
    String name;
    public BasicImp() { this.name = "Myname"; 
    public String getName() { return name; }
}

class Mix extends BasicImp implements Id,TimeStamp{
    private Id id=new IdImp();
    private TimeStamp timeStamp=new TimpStampImp();
    public Time getTimeStamp() { return timeStamp.getTimeStamp(); }
    public int getId() { return id.getId(); }

    public static void main(String[] args) {
        Mix mix=new Mix();
        System.out.println(mix.getName()+" "+mix.getId()+" "+mix.getTimeStamp());
    }
}
//output:
//Myname 1 08:00:00