1. Singly linked list
The following code defines a singly linked list, adds elements in a loop, and traverses it. The problem with this code is that it can only accept CNode types.
#include "stdafx.h"
#include "iostream.h"
class CNode //定义一个节点类
{
public:
CNode *m_pNext; //定义一个节点指针，指向下一个节点
int m_nData; //定义节点的数据
CNode() //定义节点类的构造函数
{
m_pNext = NULL; //将m_pNext设置为空
}
};
class CList //定义链表类CList类
{
private:
CNode *m_pHeader; //定义头节点
int m_nNodeSum; //节点数量
public:
CList() //定义链表的构造函数
{
m_pHeader = NULL; //初始化m_pHeader
m_nNodeSum = 0; //初始化m_NodeSum
}
CNode* MoveTrail() //移动到尾节点
{
CNode* pTmp = m_pHeader; //定义一个临时节点，将其指向头节点
for (int i=1;i<m_nNodeSum;i++) //遍历节点
{
pTmp = pTmp->m_pNext; //获取下一个节点
}
return pTmp; //返回尾节点
}
void AddNode(CNode *pNode) //添加节点
{
if (m_nNodeSum == 0) //判断链表是否为空
{
m_pHeader = pNode; //将节点添加到头节点中
}
else //链表不为空
{
CNode* pTrail = MoveTrail(); //搜索尾节点
pTrail->m_pNext = pNode; //在尾节点处添加节点
}
m_nNodeSum++; //使链表节点数量加1
}
void IterateList () //遍历链表
{
if (m_nNodeSum > 0) //判断链表是否为空
{
CNode* pTmp = m_pHeader; //定义一个临时节点，将其指向头节点
cout << pTmp->m_nData << endl; //输出节点数据
for (int i=1; i<m_nNodeSum; i++) //遍历其他节点
{
pTmp = pTmp->m_pNext; //获取下一个节点
cout <<pTmp->m_nData << endl; //输出节点数据
}
}
}
~CList() //定义链表析构函数
{
if (m_nNodeSum > 0) //链表不为空
{
CNode *pDelete = m_pHeader; //定义一个临时节点，指向头节点
CNode *pTmp = NULL; //定义一个临时节点
for(int i=0; i<m_nNodeSum; i++) //遍历节点
{
pTmp = pDelete->m_pNext; //获取下一个节点
delete pDelete; //释放当前节点
pDelete = pTmp; //将下一个节点设置为当前节点
}
m_nNodeSum = 0; //将m_NodeSum设置为0
pDelete = NULL; //将pDelete置为空
pTmp = NULL; //将pTmp置为空
}
m_pHeader = NULL; //将m_pHeader置为空
}
};
int main(int argc, char* argv[])
{
CList list; //定义链表对象
for(int i=0; i<5; i++) //利用循环向链表中添加5个节点
{
CNode *pNode = new CNode(); //构造节点对象
pNode->m_nData = i; //设置节点数据
list.AddNode(pNode); //添加节点到链表
}
list.IterateList(); //遍历节点
return 0;
}2. Template linked list
The following code modifies the original CList class and replaces the node class CNode with the template class Type, so that the linked list class CList can adapt to different types of nodes. The template class starts with the template keyword, followed by the template parameter list, which is represented by <>. The template parameter list cannot be empty. It can be a parameter type, that is, it consists of class or typename and an identifier, or it can be a non-parameter type. Another template class can have multiple type parameters.
#include "stdafx.h"
#include "iostream.h"
template <class Type> //定义类模板
class CList //定义链表类CList类
{
private:
Type *m_pHeader; //定义头节点
int m_nNodeSum; //节点数量
public:
CList() //定义链表的构造函数
{
m_pHeader = NULL; //初始化m_pHeader
m_nNodeSum = 0; //初始化m_NodeSum
}
Type* MoveTrail() //移动到尾节点
{
Type* pTmp = m_pHeader; //定义一个临时节点，将其指向头节点
for (int i=1;i<m_nNodeSum;i++) //遍历节点
{
pTmp = pTmp->m_pNext; //获取下一个节点
}
return pTmp; //返回尾节点
}
void AddNode(Type *pNode) //添加节点
{
if (m_nNodeSum == 0) //判断链表是否为空
{
m_pHeader = pNode; //将节点添加到头节点中
}
else //链表不为空
{
Type* pTrail = MoveTrail(); //搜索尾节点
pTrail->m_pNext = pNode; //在尾节点处添加节点
}
m_nNodeSum++; //使链表节点数量加1
}
void IterateList() //遍历链表
{
if (m_nNodeSum > 0) //判断链表是否为空
{
Type* pTmp = m_pHeader; //定义一个临时节点，将其指向头节点
cout << pTmp->m_nData << endl; //输出节点数据
for (int i=1; i<m_nNodeSum; i++) //遍历其他节点
{
pTmp = pTmp->m_pNext; //获取下一个节点
cout <<pTmp->m_nData << endl; //输出节点数据
}
}
}
~CList() //定义链表析构函数
{
if (m_nNodeSum > 0) //链表不为空
{
Type *pDelete = m_pHeader; //定义一个临时节点，指向头节点
Type *pTmp = NULL; //定义一个临时节点
for(int i=0; i<m_nNodeSum; i++) //遍历节点
{
pTmp = pDelete->m_pNext; //获取下一个节点
delete pDelete; //释放当前节点
pDelete = pTmp; //将下一个节点设置为当前节点
}
m_nNodeSum = 0; //将m_NodeSum设置为0
pDelete = NULL; //将pDelete置为空
pTmp = NULL; //将pTmp置为空
}
m_pHeader = NULL; //将m_pHeader置为空
}
};
class CNet //定义一个节点类
{
public:
CNet *m_pNext; //定义一个节点指针，指向下一个节点
int m_nData; //定义节点的数据
CNet() //定义节点类的构造函数
{
m_pNext = NULL; //将m_pNext设置为空
}
};
class CNode //定义一个节点类
{
public:
CNode *m_pNext; //定义一个节点指针，指向下一个节点
int m_nData; //定义节点的数据
CNode() //定义节点类的构造函数
{
m_pNext = NULL; //将m_pNext设置为空
}
};
int main(int argc, char* argv[])
{
CList<CNode> nodeList; //定义链表对象
for(int i=0; i<5; i++) //利用循环向链表中添加5个节点
{
CNode *pNode = new CNode(); //构造节点对象
pNode->m_nData = i; //设置节点数据
nodeList.AddNode(pNode); //添加节点到链表
}
nodeList.IterateList(); //遍历节点
CList<CNet> netList; //定义链表对象
for(int j=0; j<5; j++) //利用循环向链表中添加5个节点
{
CNet *pNode = new CNet(); //构造节点对象
pNode->m_nData = j; //设置节点数据
netList.AddNode(pNode); //添加节点到链表
}
netList.IterateList(); //遍历节点
return 0;
}3. Static data members of template classes
After running the code, we can see that nodeList and netList have their own static data members. However, for template instances of the same type, their static data members are shared.
#include "stdafx.h"
#include "iostream.h"
template <class Type> //定义一个模板类
class CList //定义CList类
{
private:
Type *m_pHeader; //定义头节点
int m_nNodeSum; //节点数量
public:
static int m_ListValue; //定义静态数据成员
CList() //定义构造函数
{
m_pHeader = NULL; //将m_pHeader置为空
m_nNodeSum = 0; //将m_nNodeSum置为0
}
};
template <class Type>
int CList<Type>::m_ListValue = 100; //初始化静态数据成员
class CNet //定义一个节点类
{
public:
CNet *m_pNext; //定义一个节点指针，指向下一个节点
int m_nData; //定义节点的数据
CNet() //定义节点类的构造函数
{
m_pNext = NULL; //将m_pNext设置为空
}
};
class CNode //定义一个节点类
{
public:
CNode *m_pNext; //定义一个节点指针，指向下一个节点
int m_nData; //定义节点的数据
CNode() //定义节点类的构造函数
{
m_pNext = NULL; //将m_pNext设置为空
}
};
int main(int argc, char* argv[])
{
CList<CNode> nodeList; //实例化类模板
nodeList.m_ListValue = 200; //设置静态数据成员
CList<CNet> netList; //实例化类模板
netList.m_ListValue = 300; //设置静态数据成员
cout << "nodeList实例：" << nodeList.m_ListValue << endl; //输出静态数据成员
cout << "netList实例: " << netList.m_ListValue << endl; //输出静态数据成员
return 0;
}4. Template instances of the same type share static data members
The nodeList and netList in the following code are both instances of the CNode template class. It can be seen that they do share static data members.
#include "stdafx.h"
#include "iostream.h"
template <class Type> //定义一个模板类
class CList //定义CList类
{
private:
Type *m_pHeader; //定义头节点
int m_nNodeSum; //节点数量
public:
static int m_ListValue; //定义静态数据成员
CList() //定义构造函数
{
m_pHeader = NULL; //将m_pHeader置为空
m_nNodeSum = 0; //将m_nNodeSum置为0
}
};
template <class Type>
int CList<Type>::m_ListValue = 100; //初始化静态数据成员
class CNet //定义一个节点类
{
public:
CNet *m_pNext; //定义一个节点指针，指向下一个节点
int m_nData; //定义节点的数据
CNet() //定义节点类的构造函数
{
m_pNext = NULL; //将m_pNext设置为空
}
};
class CNode //定义一个节点类
{
public:
CNode *m_pNext; //定义一个节点指针，指向下一个节点
int m_nData; //定义节点的数据
CNode() //定义节点类的构造函数
{
m_pNext = NULL; //将m_pNext设置为空
}
};
int main(int argc, char* argv[])
{
CList<CNode> nodeList; //实例化类模板
nodeList.m_ListValue = 200; //设置静态数据成员
CList<CNode> netList; //实例化类模板
netList.m_ListValue = 300; //设置静态数据成员
cout << "nodeList实例：" << nodeList.m_ListValue << endl; //输出静态数据成员
cout << "netList实例: " << netList.m_ListValue << endl; //输出静态数据成员
return 0;
}