为什么使用类模板
在前面的几章中，我们主要学习了函数模板，今天，我们来看一下类模板。在C++的模板机制中有两种模板，一种是函数模板，描述与数据类型无关的算法；一种是类模板，描述与数据类型无关的数据结构。
相信，现在一定有很多人在问，什么 是类模板？
类模板与函数模板类似，它们的本质都是一种声明，不同的是：函数模板描述的是如何生成一个函数实例，而类模板描述的是如何生成一个类。由类模板生成的类，我们称为模板类。模板类是类模板的具现，类模板是模板类的抽象。
那么，我们为什么要使用类模板呢？
为了回答这个问题，我们从下面的例子开始。
例1 实现一个整数的链表类，实现对其增删改查的成员函数
main.cpp内容如下：
#include "IntList.h"
int main()
{
CIntList IntList;
IntList.AppendNode(1);
IntList.AppendNode(2);
IntList.AppendNode(3);
IntList.AppendNode(4);
IntList.AppendNode(5);
IntList.PrintList();
if (IntList.ModifyNode(5, 6) == false)
{
std::cout << "修改数据失败!\n" << std::endl;
return 0;
}
IntList.PrintList();
if (IntList.DelNode(6) == false)
{
std::cout << "删除数据失败!\n" << std::endl;
return 0;
}
IntList.PrintList();
ListNode * pNode = NULL;
if (IntList.FindNode(5, pNode) == false)
{
std::cout << "数据5不存在!\n" << std::endl;
}
else
{
std::cout << "数据5存在!\n" << std::endl;
}
if (IntList.FindNode(3, pNode) == false)
{
std::cout << "数据3不存在!\n" << std::endl;
}
else
{
std::cout << "数据3存在!\n" << std::endl;
}
IntList.FreeList();
return 0;
}IntList.h的内容如下：#ifndef _INTLIST_H_
#define _INTLIST_H_
#include<iostream>
typedef struct _tagListNode
{
int m_nData;
_tagListNode * m_pNext;
_tagListNode()
{
m_nData = 0;
m_pNext = NULL;
}
}ListNode;
class CIntList
{
public:
CIntList();
~CIntList();
bool AppendNode(int nData);
bool DelNode(int nData);
bool ModifyNode(int nOldData, int nNewData);
bool FindNode(int nData, ListNode * & Out);
void PrintList();
void FreeList();
protected:
ListNode * m_pFirst;
};
#endifIntList.cpp的内容如下：
#include "IntList.h"
CIntList::CIntList()
{
m_pFirst = NULL;
}
CIntList::~CIntList()
{
ListNode * pTemp = m_pFirst;
while (pTemp)
{
m_pFirst = pTemp->m_pNext;
delete pTemp;
pTemp = m_pFirst;
}
m_pFirst = NULL;
}
bool CIntList::AppendNode(int nData)
{
ListNode * pNewNode = new ListNode;
if (!pNewNode)
{
return false;
}
pNewNode->m_nData = nData;
if (!m_pFirst)
{
m_pFirst = pNewNode;
return true;
}
ListNode * pTemp = m_pFirst;
while (pTemp->m_pNext)
{
pTemp = pTemp->m_pNext;
}
pTemp->m_pNext = pNewNode;
return true;
}
bool CIntList::DelNode(int nData)
{
ListNode * pPrevNode = NULL;
ListNode * pCurNode = NULL;
ListNode * pTempNode = NULL;
if (!m_pFirst)
{
return false;
}
if (m_pFirst->m_nData == nData)
{
pTempNode = m_pFirst;
m_pFirst = m_pFirst->m_pNext;
delete pTempNode;
pTempNode = NULL;
return true;
}
pPrevNode = m_pFirst;
pCurNode = m_pFirst->m_pNext;
while (pCurNode)
{
if (pCurNode->m_nData == nData)
{
pPrevNode->m_pNext = pCurNode->m_pNext;
delete pCurNode;
pCurNode = NULL;
return true;
}
pPrevNode = pCurNode;
pCurNode = pCurNode->m_pNext;
}
return false;
}
bool CIntList::ModifyNode(int nOldData, int nNewData)
{
ListNode * pCurNode = NULL;
pCurNode = m_pFirst;
while (pCurNode)
{
if (pCurNode->m_nData == nOldData)
{
pCurNode->m_nData = nNewData;
return true;
}
pCurNode = pCurNode->m_pNext;
}
return false;
}
bool CIntList::FindNode(int nData, ListNode * & Out)
{
ListNode * pCurNode = NULL;
Out = NULL;
pCurNode = m_pFirst;
while (pCurNode)
{
if (pCurNode->m_nData == nData)
{
Out = pCurNode;
return true;
}
pCurNode = pCurNode->m_pNext;
}
return false;
}
void CIntList::PrintList()
{
ListNode * pCurNode = NULL;
pCurNode = m_pFirst;
std::cout << "链表数据结点：" << std::endl;
while (pCurNode)
{
std::cout << pCurNode->m_nData << "\t";
pCurNode = pCurNode->m_pNext;
}
std::cout << std::endl;
}
void CIntList::FreeList()
{
ListNode * pTemp = m_pFirst;
while (pTemp)
{
m_pFirst = pTemp->m_pNext;
delete pTemp;
pTemp = m_pFirst;
}
m_pFirst = NULL;
return;
}运行效果如图1所示：
图1 例1的运行效果
例1完成了一个整数链表，并完成了对其增删改查，仔细观察，代码不少。倘若，我现在需要一个浮点类型的链表，功能与之相同，只是数据元素的类型不同，那么，我是否可以复用上述代码的算法呢？如果不可以，我还需要再写一遍相同的代码，只是数据元素的类型不同而已，那就太麻烦了。幸运的是C++已经为我们想到了这一点，通过使用C++提供的类模板机制，就可以复用例1代码中的算法，具体如例2所示。
例2 使用类模板完成的链表
main.cpp的内容如下：
#include "TList.hpp"
int main()
{
CTList<int> IntList;
IntList.AppendNode(1);
IntList.AppendNode(2);
IntList.AppendNode(3);
IntList.AppendNode(4);
IntList.AppendNode(5);
IntList.PrintList();
if (IntList.ModifyNode(5, 6) == false)
{
std::cout << "修改数据失败!\n" << std::endl;
return 0;
}
IntList.PrintList();
if (IntList.DelNode(6) == false)
{
std::cout << "删除数据失败!\n" << std::endl;
return 0;
}
IntList.PrintList();
ListNode<int> * pNode = NULL;
if (IntList.FindNode(5, pNode) == false)
{
std::cout << "数据5不存在!\n" << std::endl;
}
else
{
std::cout << "数据5存在!\n" << std::endl;
}
if (IntList.FindNode(3, pNode) == false)
{
std::cout << "数据3不存在!\n" << std::endl;
}
else
{
std::cout << "数据3存在!\n" << std::endl;
}
IntList.FreeList();
CTList<float> FloatList;
FloatList.AppendNode(1.1);
FloatList.AppendNode(2.2);
FloatList.AppendNode(3.3);
FloatList.AppendNode(4.4);
FloatList.AppendNode(5.5);
FloatList.PrintList();
if (FloatList.ModifyNode(5.5, 6.6) == false)
{
std::cout << "修改数据失败!\n" << std::endl;
return 0;
}
FloatList.PrintList();
if (FloatList.DelNode(6.6) == false)
{
std::cout << "删除数据失败!\n" << std::endl;
return 0;
}
FloatList.PrintList();
ListNode<float> * pNode2 = NULL;
if (FloatList.FindNode(5.5, pNode2) == false)
{
std::cout << "数据5.5不存在!\n" << std::endl;
}
else
{
std::cout << "数据5.5存在!\n" << std::endl;
}
if (FloatList.FindNode(3.3, pNode2) == false)
{
std::cout << "数据3.3不存在!\n" << std::endl;
}
else
{
std::cout << "数据3.3存在!\n" << std::endl;
}
FloatList.FreeList();
return 0;
}TList.hpp的内容如下：#ifndef _TLIST_HPP_
#define _TLIST_HPP_
#include<iostream>
template<typename T>
struct ListNode
{
T m_Data;
ListNode * m_pNext;
ListNode()
{
m_pNext = NULL;
}
};
template<typename T>
class CTList
{
public:
CTList();
~CTList();
bool AppendNode(T Data);
bool DelNode(T Data);
bool ModifyNode(T OldData, T NewData);
bool FindNode(T nData, ListNode<T> * & Out);
void PrintList();
void FreeList();
protected:
ListNode<T> * m_pFirst;
};
template<typename T>
CTList<T>::CTList()
{
m_pFirst = NULL;
}
template<typename T>
CTList<T>::~CTList()
{
ListNode<T> * pTemp = m_pFirst;
while (pTemp)
{
m_pFirst = pTemp->m_pNext;
delete pTemp;
pTemp = m_pFirst;
}
m_pFirst = NULL;
}
template<typename T>
bool CTList<T>::AppendNode(T Data)
{
ListNode<T> * pNewNode = new ListNode<T>;
if (!pNewNode)
{
return false;
}
pNewNode->m_Data = Data;
if (!m_pFirst)
{
m_pFirst = pNewNode;
return true;
}
ListNode<T> * pTemp = m_pFirst;
while (pTemp->m_pNext)
{
pTemp = pTemp->m_pNext;
}
pTemp->m_pNext = pNewNode;
return true;
}
template<typename T>
bool CTList<T>::DelNode(T Data)
{
ListNode<T> * pPrevNode = NULL;
ListNode<T> * pCurNode = NULL;
ListNode<T> * pTempNode = NULL;
if (!m_pFirst)
{
return false;
}
if (m_pFirst->m_Data == Data)
{
pTempNode = m_pFirst;
m_pFirst = m_pFirst->m_pNext;
delete pTempNode;
pTempNode = NULL;
return true;
}
pPrevNode = m_pFirst;
pCurNode = m_pFirst->m_pNext;
while (pCurNode)
{
if (pCurNode->m_Data == Data)
{
pPrevNode->m_pNext = pCurNode->m_pNext;
delete pCurNode;
pCurNode = NULL;
return true;
}
pPrevNode = pCurNode;
pCurNode = pCurNode->m_pNext;
}
return false;
}
template<typename T>
bool CTList<T>::ModifyNode(T OldData, T NewData)
{
ListNode<T> * pCurNode = NULL;
pCurNode = m_pFirst;
while (pCurNode)
{
if (pCurNode->m_Data == OldData)
{
pCurNode->m_Data = NewData;
return true;
}
pCurNode = pCurNode->m_pNext;
}
return false;
}
template<typename T>
bool CTList<T>::FindNode(T Data, ListNode<T> * & Out)
{
ListNode<T> * pCurNode = NULL;
Out = NULL;
pCurNode = m_pFirst;
while (pCurNode)
{
if (pCurNode->m_Data == Data)
{
Out = pCurNode;
return true;
}
pCurNode = pCurNode->m_pNext;
}
return false;
}
template<typename T>
void CTList<T>::PrintList()
{
ListNode<T> * pCurNode = NULL;
pCurNode = m_pFirst;
std::cout << "链表数据结点：" << std::endl;
while (pCurNode)
{
std::cout << pCurNode->m_Data << "\t";
pCurNode = pCurNode->m_pNext;
}
std::cout << std::endl;
}
template<typename T>
void CTList<T>::FreeList()
{
ListNode<T> * pTemp = m_pFirst;
while (pTemp)
{
m_pFirst = pTemp->m_pNext;
delete pTemp;
pTemp = m_pFirst;
}
m_pFirst = NULL;
return;
}
#endif运行效果如图2所示：
图2 例2的运行效果
在例2中，我们使用类模板实现了一个与具体数据类型无关的链表，并在主函数中使用这个类模板创建了两个模板类，分别针对整型和浮点类型。这两个模板类复用了相同的数诀结构算法，但是却可以操作不同类型的数据元素，这就是类模板的好处。
小结
今天，我们主要讲述了什么是类模板以及使用类模板的好处，希望大家回去能够实践一下今天的内容，加深印象。
