STL模板入门到精通（二）

一、从类模板的派生

#include <iostream>
using namespace std;

template<typename T>
class A{
public:
	A(){}
	A(T t):m(t){
		
	}
private:
	T m;
};

//不是一个类模板
class B:public A<int>{
public:
	B(){
		
	}
};

template<typename T>
class C:public A<T>{
public:
	C(){}
};

template<typename K,typename L>
class D:public A<K>{

private:
	L l;
};

int main(){
	B b;
	C<int> c;
	D<int,char> d;
	return 0;	
}

二、基础类派生出的类模板

#include <iostream>
using namespace std;

//写一个类模板 从 基础类继承
template<class T>
class BASE:public T{
public:
	void show(){
		//cout << "show()" << endl;
		T::show();这样可以调用父类的成员函数
	}
};

class Circle{
public:
	void show(){
		cout << "画一个圆" << endl;	
	}
};

class Cube{
public:		
	void show(){
		cout << "画一个正方形" << endl;	
	}
};

int main(){
	//BASE<int> b;	//这样会有问题 int不是一个类类型
	BASE<Circle> c;
	c.show();
	BASE<Cube> b;
	b.show();
	return 0;	
}

三、类模板作为成员

（1）作为成员

#include <iostream>
using namespace std;

template <typename T>
class A{
public:
	A(){}
	A(T t):t(t){}
	T getT(){
		return t;	
	}
	void show(){
		cout << "A show()" << endl;	
	}
private:
	T t;
};

//不是一个泛型的类
class B{
	
private:
	A<int> m;
};

template<typename T>
class C{
	
private:
	A<T> m;
};

int main(){
	B b;
	C<int> c;
	C<double> c1;
	
	return 0;	
}

（2）作为成员函数的返回值或参数

#include <iostream>
using namespace std;

template<typename T>
class A{

};

template<typename T>
class B{	
public:
	B(){}
	void show(A<T>& a){
		cout << "show"<< endl;	
	}
private:
	int x;
};

class C{
public:
	C(){}
	template<typename T>
	void show(A<T>& a){
		cout << "show" << endl;	
	}
private:
	int x;
};

template<typename T>
class D{
public:
	A<T> get(){
		return A<T>();	
	}
};

//类是一个普通类  但是有一个方法是泛型的方法
class E{
public:
	template<typename T>
	A<T> get(){
		return A<T>();
	}
	
};

int main(){
	A<int> a;	
	B<int> b;
	b.show(a);
	C c;
	c.show(a);//有类型参数 可以自动推导
	c.show<int>(a);
	D<int> d;
	d.get();
	E e;
	e.get<int>();//没有类型参数 无从推导
	return 0;	
}

（3）作为内部类

#include <iostream>
using namespace std;

template<typename T>
class A{
	
};

class B{
public:
	//内部类
	template<typename T>
	class C:public A<T>{
	public:
		void show(){
			cout << "show" << endl;	
		}
	};
};

int main(){
	B::C<int> c;
	c.show();
	return 0;	
}

四、模板和类的实现相分离

#include <iostream>
using namespace std;

template<class T>
class A{
public:
	/*
	void print(T& t){
		cout << "print(T& t)" << endl;
	}*/
	template<typename X>
	void print(X& t);
	/*{
		cout << "print(X& t)" << endl;	
	}*/
};

//模板类和实现相分离
template<class T>
	template<typename X>
void A<T>::print(X& t){
	cout << "print(X& t)" << endl;	
}

int main(){
	A<int> a;
	int i = 0;
	a.print(i);
	double d = 31.11;
	a.print(d);
	return 0;	
}