你也可以将用户定义的类作为一个类型参数来传递，但是请确认这个类拥有在那个模板函数或类模板中重载的所有运算符。
例如，请看程序35那个求最大值的函数。这个程序使用了一个operator ＞，所以如果我们传递自己的类的话，那么这个类必须重载了＞运算符。下面这个例子示范了这一点。
程序39.
#include ＜iostream＞
using namespace std;
template ＜typename T＞
T Maximum(const T& a, const T& b) {
return a ＞ b a : b;
}
class Point {
private:
int m_x, m_y;
public:
Point(int p_x = 0, int p_y = 0) : m_x(p_x), m_y(p_y) {
}
bool friend operator ＞ (const Point& lhs, const Point& rhs) {
return lhs.m_x ＞ rhs.m_x && lhs.m_y ＞ rhs.m_y;
}
friend ostream& operator ＜＜ (ostream& os, const Point& p) {
return os ＜＜ "(" ＜＜ p.m_x ＜＜ ", " ＜＜ p.m_y ＜＜ ")";
}
};
int main() {
Point a(5, 10), b(15, 20);
cout ＜＜ Maximum(a, b) ＜＜ endl;
return 0;
} |
程序的输出为：(15, 20)
同样，我们也能够将一个类模板作为一个模板参数传递。现在让我们来编写这样一个Point类，并将其作为一个模板参数传递给Stack类模板。
程序40.
#include ＜iostream＞
using namespace std;
template ＜typename T＞
class Point {
private:
T m_x, m_y;
public:
Point(T p_x = 0, T p_y = 0) : m_x(p_x), m_y(p_y) {
}
bool friend operator ＞ (const Point＜T＞& lhs, const Point＜T＞& rhs) {
return lhs.m_x ＞ rhs.m_x && lhs.m_y ＞ rhs.m_y;
}
friend ostream& operator ＜＜ (ostream& os, const Point＜T＞& p) {
return os ＜＜ "(" ＜＜ p.m_x ＜＜ ", " ＜＜ p.m_y ＜＜ ")";
}
};
template ＜typename T, int iSize = 10＞
class Stack {
private:
T m_pData[iSize];
int m_iTop;
public:
Stack() : m_iTop(0) {
}
void Push(T p_iData) {
m_pData[m_iTop++] = p_iData;
}
T Pop() {
return m_pData[--m_iTop];
}
T Top() {
return m_pData[m_iTop];
}
private:
Stack(const Stack＜T＞&);
Stack＜T＞& operator = (const Stack＜T＞&);
};
int main() {
Stack＜Point＜int＞ ＞ st;
st.Push(Point＜int＞(5, 10));
st.Push(Point＜int＞(15, 20));
cout ＜＜ st.Pop() ＜＜ endl;
cout ＜＜ st.Pop() ＜＜ endl;
return 0;
} |
程序的输出为：
这个程序中最重要的部分为：Stack＜Point＜int＞ ＞ st;
在这里，你必须在两个大于号之间放置一个空格，否则编译器就会将它看作＞＞（右移运算符）并产生错误。
对于这个程序我们还可以这么做，就是为模板参数传递默认的类型值，也就是将
| template ＜typename T, int iSize = 10＞ |
换为
| template ＜typename T = int, int iSize = 10＞ |
现在我们就没有必要一定在创建Stack类对象的时候传递数据类型了，但是你仍然需要书写这一对尖括弧以告知编译器使用默认的数据类型。你可以这么创建对象： Stack＜＞ st;
当你在类的外部定义（译注：原文此处是“declare”，我以为应该是“define”更准确一些。）类模板的成员函数的时候，你仍然需要写出带有模板参数的类模板全称。
程序41.
#include ＜iostream＞
using namespace std;
template ＜typename T＞
class Point {
private:
T m_x, m_y;
public:
Point(T p_x = 0, T p_y = 0);
void Setxy(T p_x, T p_y);
T getX() const;
T getY() const;
friend ostream& operator ＜＜ (ostream& os, const Point＜T＞& p) {
return os ＜＜ "(" ＜＜ p.m_x ＜＜ ", " ＜＜ p.m_y ＜＜ ")";
}
};
template ＜typename T＞
Point＜T＞::Point(T p_x, T p_y) : m_x(p_x), m_y(p_y) {
}
template ＜typename T＞
void Point＜T＞::Setxy(T p_x, T p_y) {
m_x = p_x;
m_y = p_y;
}
template ＜typename T＞
T Point＜T＞::getX() const {
return m_x;
}
template ＜typename T＞
T Point＜T＞::getY() const {
return m_y;
}
int main() {
Point＜int＞ p;
p.Setxy(20, 30);
cout ＜＜ p ＜＜ endl;
return 0;
} |
程序的输出为：(20, 30)
|