模板:把数据类型当作一种未知量(形参的形式)来处理
模板声明: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;
}