CList原理与CPlex内存管理技术

最新推荐文章于 2020-06-26 11:03:57 发布
最新推荐文章于 2020-06-26 11:03:57 发布
阅读量1k 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30934975/article/details/78778024
版权

CList，MFC中的常用链表，其本质是一个双向链表。操作包括基本的插入(头插，尾插等)，查找等常用操作。
本文代码均截取自Afxtempl.h
先看类的声明:

template<class TYPE, class ARG_TYPE = const TYPE&>
class CList : public CObject
{
    ...
}

与CArray一样，是模板类型，第一个参数为链表中保存的对象类型，第二个参数则决定了后续的插入等操作传入的是对象还是对象的引用，使用者可选。

一.内部结构

以下截取部分成员变量声明
节点定义

protected:
    struct CNode
    {
        CNode* pNext;
        CNode* pPrev;
        TYPE data;
    };

显而易见，CList是一个双向链表，有两个指针域(一个指前驱节点，一个指向后继节点)，一个数据域(用来保存对象)

再看其他成员变量

protected:
    //头节点指针，链表的第一个节点
    CNode* m_pNodeHead;
    //尾节点指针，指向链表的最后一个节点
    CNode* m_pNodeTail;
    //链表中的节点个数
    INT_PTR m_nCount;
    CNode* m_pNodeFree;
    struct CPlex* m_pBlocks;
    INT_PTR m_nBlockSize;

初始化与销毁–构造与析构

template<class TYPE, class ARG_TYPE>
CList<TYPE, ARG_TYPE>::~CList()
{
    RemoveAll();
    ASSERT(m_nCount == 0);
}

template<class TYPE, class ARG_TYPE>
CList<TYPE, ARG_TYPE>::CList(INT_PTR nBlockSize)
{
    ASSERT(nBlockSize > 0);

    m_nCount = 0;
    m_pNodeHead = m_pNodeTail = m_pNodeFree = NULL;
    m_pBlocks = NULL;
    m_nBlockSize = nBlockSize;
}

通过上面可以看出，构造函数构造了一个空链表，构造之后，链表的节点个数是0，头指针和尾指针都为NULL。析构函数通过调用RemoveAll来移除所有节点，从而清空整个链表。
下面来看几个主要函数

增加

AddHead(头插),AddTail(尾插),InsertBefore(前端插入),InsertAfter(后端插入)

头插

关键代码如下(其中涉及到的NewNode,freeNode稍后讨论，与CPlex内存管理方法有关，在此知识先看到NewNode功能，是创造一个节点，传入的参数是此节点的头指针和尾指针，分别指向此节点的前驱节点和后继节点)

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::AddHead(ARG_TYPE newElement)
{
    //通过NewNode造出一个新的节点（此节点的头指针是NULL,尾指针是旧的头指针(pNodeHead)）
    CNode* pNewNode = NewNode(NULL, m_pNodeHead);
    //节点数据域进行赋值，如果数据保存的是对象，那么会调用拷贝构造函数
    pNewNode->data = newElement;
    //把新建的节点插在头部，更新头节点
    if (m_pNodeHead != NULL)
        m_pNodeHead->pPrev = pNewNode;
    else
        m_pNodeTail = pNewNode;
    m_pNodeHead = pNewNode;
    return (POSITION) pNewNode;
}

此函数返回新插入的节点的指针，逻辑常规，双向链表头部插入。示意图如下
1.新建节点(头指针指向NULL，尾指针指向1号节点)
这里写图片描述
2.新节点拼接到旧的第一个节点之前
这里写图片描述
3.指向头结点的成员变量m_pNodeHead指向新节点
这里写图片描述

尾插

关键代码如下

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::AddTail(ARG_TYPE newElement)
{
    //新建节点，头指针指向旧的尾节点，尾指针指向NULL
    CNode* pNewNode = NewNode(m_pNodeTail, NULL);
    //节点数据域进行赋值，如果数据保存的是对象，那么会调用拷贝构造函数
    pNewNode->data = newElement;
    //把新建的节点插在尾部，更新尾节点
    if (m_pNodeTail != NULL)
        m_pNodeTail->pNext = pNewNode;
    else
        m_pNodeHead = pNewNode;
    m_pNodeTail = pNewNode;
    return (POSITION) pNewNode;
}

此函数返回新插入的节点的指针，逻辑常规，双向链表尾部插入。示意图如下
1.新建尾(头指针指向旧的尾节点m_pNodeTail，尾指针指向NULL)
这里写图片描述
2.新节点拼接到旧的最后一个节点之后
这里写图片描述
3.指向尾结点的成员变量m_pNodeHead指向新节点(更新尾节点成员变量)
这里写图片描述

中间插入(before)

InsertBefore插入，把新的节点插入到某一个节点之前,其传入的第一个参数代表链表中的一个节点,新插入的节点在这个节点之前
before插入与after插入原理相同，所以后面只看after插入，before列出函数声明

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::InsertBefore(POSITION position, ARG_TYPE newElement);

position指向插入的位置(实现中强转成了Node*)，newElement为要插入的元素，可以是对象

中间插入(after)

afterBefore插入，把新的节点插入到某一个节点之后,其传入的第一个参数代表链表中的一个节点,新插入的节点在这个节点之后
关键代码如下
position指向插入的位置(实现中强转成了Node*)，newElement为要插入的元素，可以是对象

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::InsertAfter(POSITION position, ARG_TYPE newElement)
{
    // Insert it before position
    CNode* pOldNode = (CNode*) position;
    //新建节点，节点的头指针指向pOldNode ，尾指针指向pOldNode的下一个节点
    CNode* pNewNode = NewNode(pOldNode, pOldNode->pNext);
    //节点数据域进行赋值，如果数据保存的是对象，那么会调用拷贝构造函数
    pNewNode->data = newElement;
    //以下代码吧新建节点插入到目标位置pOldNode之后(pOldNode下一个节点之前)
    if (pOldNode->pNext != NULL)
    {
        ASSERT(AfxIsValidAddress(pOldNode->pNext, sizeof(CNode)));
        pOldNode->pNext->pPrev = pNewNode;
    }
    else
    {
        ASSERT(pOldNode == m_pNodeTail);
        m_pNodeTail = pNewNode;
    }
    pOldNode->pNext = pNewNode;
    //返回新插入的节点
    return (POSITION) pNewNode;
}

示意图如下:
1.新建节点
这里写图片描述
2.插入新建节点(这里假定插入到1号节点之后)
这里写图片描述

删除

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::RemoveAt(POSITION position)
{
    ASSERT_VALID(this);

    CNode* pOldNode = (CNode*) position;
    ASSERT(AfxIsValidAddress(pOldNode, sizeof(CNode)));

    // remove pOldNode from list
    if (pOldNode == m_pNodeHead)
    {
        m_pNodeHead = pOldNode->pNext;
    }
    else
    {
        ASSERT(AfxIsValidAddress(pOldNode->pPrev, sizeof(CNode)));
        pOldNode->pPrev->pNext = pOldNode->pNext;
    }
    if (pOldNode == m_pNodeTail)
    {
        m_pNodeTail = pOldNode->pPrev;
    }
    else
    {
        ASSERT(AfxIsValidAddress(pOldNode->pNext, sizeof(CNode)));
        pOldNode->pNext->pPrev = pOldNode->pPrev;
    }
    FreeNode(pOldNode);
}

修改

pos为要修改节点的地址,关键代码如下（要修改哪一个节点）

template<class TYPE, class ARG_TYPE>
AFX_INLINE void CList<TYPE, ARG_TYPE>::SetAt(POSITION pos, ARG_TYPE newElement)
    { CNode* pNode = (CNode*) pos;
        ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
        //修改节点，要调用拷贝构造函数
        pNode->data = newElement; }

查找

所谓查找，就是传入一个整形的索引，返回”索引所在位置的Node”,也就是”获取第Index个(Index从0开始计数，0表示head节点)Node”。

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::FindIndex(INT_PTR nIndex) const
{
    ASSERT_VALID(this);

    if (nIndex >= m_nCount || nIndex < 0)
        return NULL;  // went too far
    //从头结点开始查找
    CNode* pNode = m_pNodeHead;
    //循环遍历节点，遍历nIndex次
    while (nIndex--)
    {
        ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
        //pNode依次往后移
        pNode = pNode->pNext;
    }
    //循环结束后，返回Index号节点Node指针
    return (POSITION) pNode;
}

//真正的”查找节点”
下面这个函数从某一个位置开始向后查找，与希望查找的数据(可能是对象)进行”数据比较”,会调用对象的比较函数，返回符合比较条件的值，比较函数由使用者自己定义。

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::Find(ARG_TYPE searchValue, POSITION startAfter) const
{
    ASSERT_VALID(this);

    CNode* pNode = (CNode*) startAfter;
    if (pNode == NULL)
    {
        pNode = m_pNodeHead;  // start at head
    }
    else
    {
        ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
        pNode = pNode->pNext;  // start after the one specified
    }

    for (; pNode != NULL; pNode = pNode->pNext)
        if (CompareElements<TYPE>(&pNode->data, &searchValue))
            return (POSITION)pNode;
    return NULL;
}

CPlex内存管理方法

再看CList的NewNode之前，先看看MFC中简单粗暴的CPlex内存管理方法
通过afxplex_.h和Plex.cpp来看CPlex类是如何管理内存的

struct CPlex
{
    CPlex* pNext;
    // BYTE data[maxNum*elementSize];

    void* data() { return this+1; }

    static CPlex* PASCAL Create(CPlex*& head, UINT_PTR nMax, UINT_PTR cbElement);
            // like 'calloc' but no zero fill
            // may throw memory exceptions

    void FreeDataChain();       // free this one and links
};

首先看Create

CPlex* PASCAL CPlex::Create(CPlex*& pHead, UINT_PTR nMax, UINT_PTR cbElement)
{
    ASSERT(nMax > 0 && cbElement > 0);
    if (nMax == 0 || cbElement == 0)
    {
        AfxThrowInvalidArgException();
    }
    //重点关注下面这里
    CPlex* p = (CPlex*) new BYTE[sizeof(CPlex) + nMax * cbElement];
            // may throw exception
    p->pNext = pHead;
    pHead = p;  // change head (adds in reverse order for simplicity)
    return p;
}

内存管理结构

由着几行来看他的结构

    CPlex* p = (CPlex*) new BYTE[sizeof(CPlex) + nMax * cbElement];
            // may throw exception
    p->pNext = pHead;
    pHead = p;  // change head (adds in reverse order

其管理内存示意图是这样的
这里写图片描述

每次在分配内存的时候，函数的后面两个参数是用户分配的内存，而实际多分配了一个CPlex内存来保存指针，以便让这个”链表链起来”，传入的Head表示链表的头节点，从类的声明来看，并没有成员变量保存这个头结点，这个头结点由使用者自己保存,首次Create内存时，头结点置NULL传入即可。

获取分配的内存

void* data() { return this+1; }

通过CPlex*类型的指针来获取内存块,this+1也就是上图中的Block位置，this也就是上图中的内存块的首地址。

销毁内存

void CPlex::FreeDataChain()     // free this one and links
{
    CPlex* p = this;
    while (p != NULL)
    {
        BYTE* bytes = (BYTE*) p;
        CPlex* pNext = p->pNext;
        delete[] bytes;
        p = pNext;
    }
}

使用者通过链表的首址Head来调用这个方法即可。

用这种方式管理内存，每次多分配一个sizeof(CPlex)
具体使用，看看后面CList是如何来使用这个CPlex类的

NewNode函数

上面函数一直在用NewNode来创建节点，那么他是否每次都需要重新”new”一个Node?首先，构造函数中已经把m_pNodeFree初始化为了NULL，m_nBlockSize初始化为了10(通过默认参数，使用者可选)

template<class TYPE, class ARG_TYPE>
typename CList<TYPE, ARG_TYPE>::CNode*
CList<TYPE, ARG_TYPE>::NewNode(CNode* pPrev, CNode* pNext)
{
    if (m_pNodeFree == NULL)
    {
        //如果备用的Node没有了(Null==m_pNodeFree)，就要新建内存来存储备用的Node
        CPlex* pNewBlock = CPlex::Create(m_pBlocks, m_nBlockSize,
                 sizeof(CNode));

        // chain them into free list
        CNode* pNode = (CNode*) pNewBlock->data();
        // free in reverse order to make it easier to debug
        pNode += m_nBlockSize - 1;
        for (INT_PTR i = m_nBlockSize-1; i >= 0; i--, pNode--)
        {
            pNode->pNext = m_pNodeFree;
            m_pNodeFree = pNode;
        }
    }
    ENSURE(m_pNodeFree != NULL);  // we must have something
    //把备用Node中取出一个Node出来给使用者，此时备用的Node就减少一个
    CList::CNode* pNode = m_pNodeFree;
    m_pNodeFree = m_pNodeFree->pNext;
    pNode->pPrev = pPrev;
    pNode->pNext = pNext;
    m_nCount++;
    ::new( (void*)( &pNode->data ) ) TYPE;
    return pNode;
}

从上面可以看出，实际上并不是每次都要NewNode,CList根据m_nBlockSize大小已经一次性的New出了m_nBlockSize个Node,当需要Node时，就在已经new的Node中取出一个给使用者。

每一个保存Node的Block内存如下
这里写图片描述
CList正是这样来预存备用的Node的，这里的Node是备用的

FreeNode

主要代码如下

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::FreeNode(CNode* pNode)
{
    //析构Node保存的对象
    pNode->data.~TYPE();
    //之后把Node重新放入储备的Node当中,以便下次NewNode
    pNode->pNext = m_pNodeFree;
    m_pNodeFree = pNode;
    m_nCount--;
    // if no more elements, cleanup completely
    if (m_nCount == 0)
        RemoveAll();
}

FreeNode就是”释放”一个Node,这里的释放实质上是把Node又放回备用Node的储备中，由已”分配状态“变为”待分配状态“。直观的做法是m_pNodeFree前移，m_pNodeFree前移就表示可分的Node多了一个

RemoveAll

主要代码如下

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::RemoveAll()
{
    //释放链表(这个链表是使用者直接使用的链表)
    CNode* pNode;
    for (pNode = m_pNodeHead; pNode != NULL; pNode = pNode->pNext)
        pNode->data.~TYPE();
    m_nCount = 0;
    m_pNodeHead = m_pNodeTail = m_pNodeFree = NULL;
    //释放存储"备用Node"的CPlex
    m_pBlocks->FreeDataChain();
    m_pBlocks = NULL;
}

释放整个CList保存的链表空间，其中分两步
1.释放链表(这个链表是使用者直接使用的链表)
2.释放存储”备用Node”的CPlex

注意:和CArray一样，妥善处理拷贝构造函数和析构函数，CList操作中多次涉及到拷贝构造函数。小心使用防止内存泄漏

在路上xibuniu123
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
clist.zip_CList
09-24
通过查看和运行这个示例，学习者可以更好地理解CComboBox的工作原理以及如何与之交互。 总结来说，CList控件是MFC中的一个重要组件，用于显示和管理列表数据。对于初学者，理解和掌握如何在MFC应用中使用CList控件...
MFC中CList类使用注意
ellor的专栏
07-29 3850
初学mfc者，往往对CList等mfc的Collect类的使用感到迷惑，在使用中经常会遇到许多问题，导致对vc中的Collect类的使用产生了惧怕。以下，就个人经历而言,告诉大家如何使用CList。CList是一个双向链表类。1、头文件名不可少Clist类定义在Afxtempl.h 头文件中，因此在使用该类时，需要加这个头文件名。2、理解CList的声明和构造方法CList
CList的用法理解
曾伟的专栏
03-21 8420
CList是一个双向链表类。CList的优势是快速灵活的插入和删除。但是在访问元素的时候，会多一个N的时间复杂度。在元素很多的时候，建议把数据分段存储。 1、包含头文件Afxtempl.h      在你要使用CList链表类的地方，使用#include  ,或者直接在stdafx.h中包含这句。 2、理解CList的声明和构造方法 CList的声明如下： template class
CList如何使用，用法举例
月光秦王
03-01 2501
此前，我们已经知道了POSITION，其实就是一个类似于学号的指针，我们也知道了CArray的效率将会随着元素数目的变化，而不断恶化。现在，似乎已经到了不得不讲讲CList的时候了。 CList与CArray，虽然他们的内部数据结构截然不同，但是MFC为我们提供的接口函数，还是比较相似的。在使用CList之前，我们必须要知道，它是以双向链表的形式存在的。 对于链表来说，一些常用的操作无非就是：
CList使用说明
liups的专栏
01-09 2087
http://blog.sina.com.cn/s/blog_70441c8e0101aiwf.html PS：有修订,必须加入MFC库 CList是通用型的列表类，你可以存放指定的数据类型，用法如下： CList list; 这样就指定了CList中存放的是CPoint类型的引用； CPtrList，CObList，CStringList都是具体的用于某种类型的
MFC CList使用
我的英文站点：https://iorilan.medium.com/
03-27 4346
转自：http://blog.sina.com.cn/s/blog_5cda82f40100aw58.html 一、类的概要和头文件 1. CList类：产生不定类型的列表，是一个集合类，也是一个双向链表类，是一个类模板。 2. #include "Afxtempl.h"   //包含头文件 3. CList的构造函数，举例如下： CList list;
CList 简单用法
Safedebug的博客
12-24 905
首先来看微软原文 template class CList : public CObject TYPE Type of object stored in the list. ARG _ TYPE Type used to reference objects stored in the list. Can be a reference. 首先大家明白一点，CList就是一个 链表 然后，需要
CList.zip_CList
09-14
它的主要优点是提供了一种高效的方式来管理内存，同时提供了便捷的迭代器和成员函数来操作链表。 CList类的创建与初始化： 1. 创建CList对象时，可以指定元素类型和元素比较函数指针，用于元素的排序和查找。例如：...
CList.rar_CList
09-14
CList是MFC（Microsoft Foundation Classes）...通过这个测试程序，我们可以实践CList类的这些操作，理解其工作原理，从而更好地在实际项目中应用CList。对于初学者，这是一个很好的起点，可以加深对MFC容器类的理解。
CList_1.rar_CList
09-24
《深入理解VC++ CList：动态数据操作与实践》 在C++编程中，MFC（Microsoft Foundation Classes）库提供了一系列方便的容器类，其中CList是一个常用的动态链表类，用于存储和管理元素。本篇文章将通过分析提供的...
VC++ CList动态的添加删除数据实例
03-31
VC++ CList动态的添加删除数据实例 一个动态的VC++ CList添加删除数据实例，其实是简单的不能简单的，不过入门者还有些并不熟悉，所以本站尽量多发布些对新手们有帮助的初级实例，编程高手也是从低手磨练而来的
CList的使用
07-16
是一个MFC小程序 点击窗口 移动放开鼠标 记录两点 存入链表 点击回车键取出链表元素并画直线
CArray,Clist全部有关数组、列表、映射类
11-25
CArray,Clist全部有关数组、列表、映射类，即CArray，Clist,CMap三个序列的所有类
基于MFC链表类CList的使用例程
10-30
本资源是基于MFC集合类中链表类CList的简单应用，适用于VC++编程开发小白使用，对于加深对MFC集合类的理解很有帮助！
clist.rar_RAW_linux clist
09-23
总结来说，“clist.rar_RAW_linux clist”是一个关于Linux下字符列表原始数据结构的主题，涉及到了如何高效管理字符序列以及与IEEE 754浮点运算相关的知识。通过“ieee.h”和“clist.h”这两个文件，我们可以学习到...
MFC中CList使用方法以及项目踩坑
qq_42516974的博客
01-17 3825
最近项目里一个问题要用到容器存储数据，因为C++的stl容器在MFC中不能用，因为会引起运算符重载，所以只能用MFC中的CList容器，但是csdn上的CList博客都是抄来抄去，也没有具体的用法实例，太恶心了，自己折腾了半天才找到遍历CList容器的方法; 1.CList容器基本操作: 标题/末尾访问 GetHead 返回列表的标题元素（不能为空） GetTail 返回列表的末尾元素（不能为空）...
CList类
热门推荐
zhoubl668的专栏：远帆，梦之帆！
02-10 1万+
MFC中CList类使用注意    初学mfc者，往往对CList等mfc的Collect类的使用感到迷惑，在使用中经常会遇到许多问题，导致对vc中的Collect类的使用产生了惧怕。以下，就个人经历而言,告诉大家如何使用CList。CList是一个双向链表类。1、头文件名不可少Clist类定义在Afxtempl.h 头文件中，因此在使用该类时，需要加这个头文件名。2、理解CList的声明和构
[MFC] CList
weixin_34008933的博客
02-22 228
1、CList说明   类CList支持可按顺序或按值访问的非唯一对象的有序列表。CList 列表与双链接列表行为相似。 template &lt; class TYPE, class ARG_TYPE &gt; class CList : public CObject 参数：TYPE存储在列表中的对象类型。ARG_TYPE用于参考存储在列表中的对象的类型。可以是一个参考。 例如：CLi...
CList
cslie的专栏
06-26 325
头文件 #include <cstdio> #include <afxtempl.h> 代码 // 源代码POSITION定义 ，一个结构指针 //struct __POSITION {}; //typedef __POSITION* POSITION; //源代码节点定义 ，双向链表 //struct CNode //{ // CNode* pNext; // CNode* pPrev; // TYPE data; //}; CLis.
vc++ CList
最新发布
07-27
CList 是 MFC（Microsoft Foundation Classes）中的一个类模板，它实现了一个双向链表。在 VC++ 中使用 CList 可以方便地进行链表操作，如插入、删除、移动等。 要使用 CList，首先需要包含头文件 afxtempl.h，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值