CList的使用

初学mfc者,往往对CList等mfc的Collect类的使用感到迷惑,在使用中经常会遇到许多问题,导致对vc中的Collect类的使用产生了惧怕。以下,就个人经历而言,告诉大家如何使用CList

CList是一个双向链表类。

1、头文件名不可少

Clist类定义在Afxtempl.h 头文件中,因此在使用该类时,需要加这个头文件名。

2、理解CList的声明和构造方法

CList的声明如下:

template< class TYPE, class ARG_TYPE >class CList : public CObject

由此,我们知道CList是一个模版类,那么他的两个class是什么意思呢?

下面看一个例子:

CList<CString ,CString&> list;//链表对象1

CList<CString,CString> list2;//链表对象2

这里的第一个参数CString是实例化的类型,第二个参数是类的成员函数的参数的调用形式,通常是类型 引用,当然也可以是对象,而不是引用。对象和引用的区别,可以看一下C++基础知识方面的书。
3、使用CList的迭代器
      迭代器是近年在链表使用中的一个常用技术。如果大家学过java,就会知道,在java中,会有专门的一个迭代器类,这个迭代器类用来访问Collect中的数据元素。在mfc中,在CList中,定义了几个迭代器的函数。他们方便了我们去访问数据元素。
GetHeadPosition Returns the position of the head element of the list.
GetTailPosition Returns the position of the tail element of the list.
GetNext Gets the next element for iterating.
GetPrev Gets the previous element for iterating.
以上是四个迭代器函数。前两个他们的返回值是POSITION,它是mfc中定义的的一种专门访问Collect类的一个数据类型。用他来表示元素的位置。
// abstract iteration position
struct __POSITION { };
typedef __POSITION* POSITION;
以上是在跟踪POSITION定义中找到的。由此,我们知道POSITION是个抽象的迭带器位置。至于怎么实现,我也只能知道这么多,如果有哪位高手知道的话,一定要告诉我们哦。
下面我们利用给出的迭代器函数,对下面建立的链表进行遍历:
CList<CString ,CString&> list;
CString str1="hello";
CString str2="world";
CString str3="my";
CString str4="life";
list.AddTail(str1);
list.AddTail(str2);
list.AddTail(str3);
list.AddTail(str4);
POSITION pos = list.GetHeadPosition();
while(pos!=NULL)
{
        pDC->TextOut(200,200,GetNext( POSITION& rPosition ) );//假设代码是在View类中的OnDraw()
                                                                                                  //函数里
}
这样就完成了对list的遍历。
4、CList的其它函数:
       CList的其它函数,大家可以参考一下MSDN,在那里每个函数都讲得很清楚。这里就不再多介绍。
5、CList的元素
       对于系统定义的类,可以直接在CList中使用。而对于用户自定义的类,如果这个类继承了CObject类,在使用CList时,需要将用户自定义的类实现操作符=的重载,否则系统将会报错。以下举一简单的CNode例子,使之实现操作符=的重载:
class CNode : public CObject
{
public:
       CPoint point;
       CNode()
      {
             point.x=0;
             point.y=0;
      }
      void operator = (CPoint& p)//运算符=的重载
     {
         point=p;
     }
};
6、CList的序列化:
      CList是一个继承了CObject的类,并且已经实现了Serialize(CArchive& ar)的函数,所以,对CList进行串行序列化不需要的。
     如果在CList类在CDocument定义了其对象list,那么在文档的Serialize(CArchive& ar)只需作如下修改:
void CDdfDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
    // TODO: add storing code here
    list.Serialize(ar);
}
else
{
    // TODO: add loading code here
list.Serialize(ar);
}
}
这样,就实现了文档的串行化,如果使用mfc生成的框架,那么我们就可以直接将这个list的数据保存到文件,并能读取了。

 

 

CList 类

C++中实现通用数据结构

在程序设计当中经常会出现使用同种数据结构的不同实例的情况。例如:在一个
程序中可以使用多个队列、树、图等结构来组织数据。同种结构的不同实例,也
许只在数据元素的类型或数量上略有差异,如果对每个实例都重新定义,则非常麻
烦且容易出错。那么能否对同种类型数据结构仅定义一次呢?答案是肯定的,C++
提供的类模板(Class Template)就可以实现该功能。
一、类模板
类模板是C++提供的一种特殊机制,通过它我们可以定义一种特殊的类(称为模板
类),在类的定义中可以包含待定的类型参数,在声明类的实例时,系统会自动根据
传递的类型生成用户想要生成的类实例。下面是用C++实现的一个简单的模板类
Clist的定义。
Template <class T, int I> class CList
{
public:
int SetItem(int Index, const T &Item);
int GetItem(int Index, T &Item);
private:
T Buffer[I];
}
在这里,T是类型参数,I是整型常量参数。T和I的实际值是在声明具体类实例时指
定的。模板类的<>号内可以包括任意个类型参数和常量参数(至少要有一个参数
)。类型参数和常量参数可以是任何合法的标准类型和用户自定义类型,包括简单
类型及各种结构体。同其他类一样,类成员函数SetItem的实现可以在类定义内完
成,也可以在类CList定义处实现:
template<class T, int I> int CList<T, I>::SetItem(int Index, const T
&Item)
{
if ( (Index<0)||(Index>I-1) )
 return 0; // 出错
Buffer[Index]= Item ;
 return 1; // 成功
}
值得注意的是,在类定义外完成函数实现时,必须以关键字template和类模板定义
中相同的参数表(<>号内的)开头(上例为template<class T, int I>),并且范围
分解操作符前的类名后应跟上模板参数名清单(上例为CList<T, I>)。另外,与非
模板类不同的是,必须将函数实现包括在调用它的每个源文件中,使编译器能从函
数实现产生代码。通常的做法是将模板类的函数实现也放在定义该类的头文件中
,这样只需在调用的源文件中包含该头文件即可。
那么,如何使用生成特定的类实例呢?我们可以像使用其他类一样来使用模板类,
不过必须指定模板参数的值。例如采用如下声明:
CList <int, 100> IntList;
则使IntList成为CList类的实例,每次出现的T参数都换成int, 每次出现的I参数
都换成100。这样,IntList类中的Buffer就是一个长度为100的整型数组,
SetItem和GetItem函数参数是int值的引用。例:
IntList.SetItem(0, 5); //给数组第一个元素赋为整数5
模板类还可以像其他类一样可以定义构造函数和析构函数。下面我们以一种简单
的数据结构——堆栈为例,来说明如何用类模板来构造通用数据结构。
二、 利用类模板实现通用堆栈结构
任何抽象数据结构在计算机中的实现,归根结底都只有两种方式:顺序存储(用数
组实现),链式存储(用指针实现)。堆栈也不例外,按其实现方式可分为顺序栈(用
数组实现)和链栈(用指针实现)。
1. 通用顺序栈的实现
因为顺序栈中的元素在空间上连续存储,栈顶的元素位置需要注明,所以构造顺序
栈的模板类应该有这样的一些成员变量:一个待定类型和长度的数组Buffer,一个
记录栈顶元素的数组下标的整型变量top。堆栈的基本操作主要有:入栈(Push)、
出栈(Pop)、置空(SetEmpty)、判断当前状态(IsEmpty)等,它们应用模板类的成
员函数来实现。作为一个标准的类,它还应该有自己的构造函数和析构函数。具
有这些功能的模板类,就可以作为一个通用的顺序栈来使用了。该类的定义如下
:
template <class T,int SIZE> class CArrayStackTemp
{
public:
CArrayStackTemp () //缺省构造函数,构造一个空堆栈
{
top= -1;
};
~ CArrayStackTemp (){};//析构函数
 void SetEmpty (); //置空堆栈
 bool IsEmpty(); //判断堆栈是否为空
 bool Push(T element); //入栈
 bool Pop(T& element);//出栈
private:
T Buffer[SIZE];
 int top;
};
与堆栈的基本操作相对应的成员函数的实现如下:
template <class T, int SIZE> void CArrayStackTemp<T, SIZE>::
SetEmpty ()
{
top= -1; //将栈顶指针赋 -1,并不实际清除数组元素
}
template <class T, int SIZE> bool CArrayStackTemp<T, SIZE>:: IsEmpty
()
{
return(top == -1);
}
template <class T, int SIZE> bool CArrayStackTemp<T, SIZE>:: Push (T
element)
{
top++;
if (top>SIZE-1)
{
top--;
return false; //堆栈已满,不能执行入栈操作
}
Buffer[top]=element;
return true;
}
template <class T, int SIZE> void CArrayStackTemp<T, SIZE>:: Pop (T&
element)
{
if (IsEmpty())
 return false;
element =Buffer[top];
top--;
return true;
}
根据实际需要,还可以扩充堆栈功能。例如:加入取栈顶元素、求堆栈长度等操作
,其方法如上。
2. 通用链栈的实现
模板类中允许使用指针和定义自己的结构,这就为实现链式结构提供了保证。这
里采用一个单链表来实现堆栈,栈顶指针指向链表的第一个结点,入栈和出栈均在
链表的头进行。该模板类的定义如下:
template <class T> class CLinkStackTemp
{
public:
 //类的缺省构造函数,生成一个空堆栈
CLinkStackTemp ()
{
top=NULL;
};
~ClinkStackTemp(){}; //析构函数
 //定义结点结构
 struct node
{
T
  data; //入栈元素
 node* next; //指向下一结点的指针
};
 void SetEmpty(); //置空堆栈
 bool IsEmpty(); //判断堆栈是否为空
 bool Push(T element); //压入堆栈
 bool Pop(T& element);//弹出堆栈
private:
 node* top;
};
该类的成员函数实现如下:
template <class T> void CLinkStackTemp <T>::SetEmpty()
{
//释放堆栈占用的内存
node* temp;
while (top!=NULL)
{
 temp=top;
 top=top->next;
 delete temp;
}
}
template <class T> bool CLinkStackTemp <T>::IsEmpty()
{
return (top==NULL);
}
template <class T> bool CLinkStackTemp <T>::Push(T element)
{
node* temp=new node();
if (temp ==NULL)
 return false ;
temp->data=element;
temp->next=top;
top=temp;
return true;
}
template <class T> bool CLinkStackTemp <T>::Pop(T& element)
{
if ( IsEmpty())
 return false;
node* q = top;
element = top->data;
top=top->next;
delete q;

return true;
}
与顺序栈的实现略有不同,链栈不必指定栈的容量,其大小可以是近似"无限"的。
为了程序的使用方便,我们同样可以加入一些增强的功能。
三、 通用堆栈类的使用
通用堆栈类的使用较为简单,堆栈类的实例就是一个可以方便使用的堆栈。对堆
栈的操作都是通过类的成员函数来实现的。使用的具体步骤如下:
1. 在要使用堆栈类的程序代码的文件开头包括模板类及其成员函数的定义。
2. 类的实例化,可声明成变量,也可以声明它的指针,如:
CArrayStackTemp <int, 100> intStack; //生成一个长度为100的int型堆栈
//生成一个元素为Record型的堆栈,Record为自定义结构
CLinkStackTemp <Record>* RecordStack;
RecordStack=new CLinkStackTemp<Record>;
应注意在定义顺序栈时,必须指定栈的大小,而链栈则不必。另外在指定指针类型
和执行new操作时,必须对模板参数赋值,并且前后要一致。
3. 对堆栈进行操作,如:
intStack.Push(3); //将整数3入栈
RecordStack.SetEmpty(); //将堆栈置空
无论我们使用哪种堆栈类,对用户来讲都是透明的,操作起来并无差别。

CList类的两个参数什么意思啊?第一个参数表示链表中存储的数据类型,后面一个表示链表类中函数参数的传递方式,通常为存储数据类型的引用。
CList<string,string> MyList_x;
CList<string,string&>MyList_y;
//两种方式实现的功能一样,不过后面一个更加高效。
CList <int,string> list;声明方式就是错误,
CList <int,int>list1;CList <int,char>list2;CList<char,int> list3;都是可以接受的声明方式。
我举一个函数例子来说明这一点。
template <class TYPE ,class ARG_TYPE>
class ELEMENT
{
TYPE data;
public:
TYPE set_value(ARG_TYPE m){ data=m+m;}
};
进行如下调用
string z("hello");
ELEMENT<string,string> sample;
sample.set_value(z);
ELEMENT<string,string&> example;//sample,example得到的是完全一样的数据,但是第二种操作高效
example.set_value(z);
ELEMENT<int,char> demo_a;//由于int,char 支持自动类型转化,可以混合两种类型进行声明
ELEMENT<int,int> demo_b;
ELEMENT<char,char> demo_c;
ELEMENT<char,int> demo_d;
demo_a.set_value(''c'');
demo_b.set_value(20);
demo_c.set_value(''c'');
demo_d.set_value(15);
//ELEMENT <int ,string> demo;//这两行错误调用,单纯该行的申明可以通过编译,
//demo.set_value(string(hello));//但是有了这一行编译器就不客气了,不能通过

 

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页