C++学习-模板

模板:把数据类型当作一种未知量(形参的形式)来处理

模板声明:template<class T1,....> ....
     

1.函数模板

//STL  标准模板类库
#include <iostream>
#include <string>
using namespace std;
//为什么有模板:整合
template <typename T>
T sum(T a, T b)
{
	return a + b;
}
int main()
{
	//模板实例化--->模板的使用
	//1.隐式调用
	int a = 1;
	int b = 2;
	cout << sum(a, b) << endl;
	//2.显示调用（显示实例化）函数<类型>（实参）
	cout << sum<double>(1.11, 2.11) << endl;
	system("pause");
	return 0;
}

2.类模板

#include <iostream>
using namespace std;
template <typename T>
class C
{
public:
	C(T x, T y) :m_x(x), m_y(y){}
	T Max()const
	{
		return m_x > m_y ? m_x : m_y;
	}
	T Min()const;
private:
	T m_x;
	T m_y;
};

template <typename T>
T C<T>::Min()const
{
	return m_x > m_y ? m_y : m_x;
}
//父类是模板类，继承后的子类一定是模板类
template <typename T>
class B :public C<T>
{
public:

private:
};


int main()
{
	double x = 1.11, y = 1.22;
	//类模板必须要显式实例化
	//类名<类型>对象
	C<double> c(x, y);
	cout << c.Max() << endl;
	system("pause");
	return 0;
}

3.模板的特化

#include<iostream>
using namespace std;

template <typename A ,typename B>
class Ez
{
public:
	static void show()
	{
		cout << "Ez(A,B)" << endl;
	}
};
//完全特化
template <>
class Ez<int ,double>
{
public:
	static void show()
	{
		cout << "Ez(int,double)" << endl;
	}
};
//局部特化
template <typename T>
class Ez<T,T>
{
public:
	static void show()
	{
		cout << "Ez(T,T)" << endl;
	}
};
template <typename T>
class Ez<T*, T*>
{
public:
	static void show()
	{
		cout << "Ez(T*,T*)" << endl;
	}
};

int main()
{
	//静态成员函数不需要对象就可以使用
	Ez<int, double>::show();
	Ez<int, int>::show();
	Ez<int *, int *>::show();
	return 0;
}

4.模板的重载

#include <iostream>
using namespace std;
//int const* p和 const int *p==没区别
//int const *p   int * const p;

template <typename T>
T const& Max(T const& x, T const& y)
{
	cout << 1 << endl;
	return x > y ? x : y;
}
template <typename T>
//T * :返回值类型T*  x,  T* y
T* const& Max(T* const& x, T* const& y)
{
	cout << 2 << endl;
	return *x > *y ? x : y;
}
int  Max(int a, int b)
{
	cout << 3 << endl;
	return a > b ? a : b;
}

int main()
{
	int a = 123, b = 134;
	cout << Max(a ,b) << endl;
	//模板与普通函数的重载:优先调用普通函数 实参和普通函数的类型一致
	int *p = &a, *q = &b;
	//模板和模板的重载：满足重载的要求 ，调用先调用满足匹配的模板
	cout << *Max(p, q) << endl;
	system("pause");
	return 0;
}

5.模板类的继承

//模板类，必须显式实例化
//模板类： 类存在未知类型
#include <iostream>
#include <string>
using namespace std;
template<typename T>
class Any
{
public:
	Any(T x, T y) :x(x), y(y){}
	T Max() const
	{
		return x > y ? x : y;
	}
	T Min()const;
protected:
	T x;
	T y;
};
//类外实现  ：模板类，他不是一个完整的类型，所以你在使用过程要加上类型说明：<类型>
template <typename T> 
T Any<T>::Min() const
{
	return x > y ? y : x;
}

template <typename T>
class thing :public Any<T>
{
public:

protected:

};

template <typename T>
class StaticData
{
public:
protected:
	T day;
	static int s_data;
};
template <typename T>
int StaticData<T>::s_data = 1;


int main()
{
	//类模板的实例化
	Any<string> object("abc","acd");
	cout<<object.Max()<<endl;
	cout << object.Min() << endl;
	system("pause");
	return 0;
}

6.模板中的静态成员

#include <iostream>
using namespace std;
class A
{
public:
	A(int data):m_data(data){}
	int m_data;
	static int s_data;
};
int A::s_data = 10;

template <typename T>
class B
{
public:
	B(int data) :m_data(data){}
	int m_data;
	static int s_data;
};
template <typename T>
int B<T>::s_data = 100;

int main()
{
	return 0;
}

7.自定义类型当作模板参数实例化

#include<iostream>
using namespace std;
template <typename T>
class Data
{
public:
	Data(T a, T b) :x(a), y(b){}
	T& getx()
	{
		return x;
	}
	T& gety()
	{
		return y;
	}
protected:
	T x;
	T y;
};
template <typename E >
//比较的是对象类型
E &Max(E &a, E &b)
{
	return a.getx() > b.getx() ? a : b;
}


int main()
{

	Data<int> myData(1, 2);
	Data<int> myData2(2, 3);
	//自定义类型的实例化
	//返回的是一个对象 
	//对象的不能够直接输出  ----输出成员
	cout <<"x="<<Max<Data<int>>(myData,myData2).getx() << endl;
	Max<Data<int>>(myData, myData2).gety() = 6;
	cout << "y=" << Max<Data<int>>(myData, myData2).gety() << endl;
	system("pause");
	return 0;
}