CList源码解析

最新推荐文章于 2021-04-09 21:00:44 发布
最新推荐文章于 2021-04-09 21:00:44 发布
阅读量927 收藏 4
点赞数 1
文章标签： CList
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/q_023/article/details/68485768
版权

（1）CList Class Members

Construction

CList Constructs an empty ordered list.

Head/Tail Access

GetHead Returns the head element of the list (cannot be empty).
GetTail Returns the tail element of the list (cannot be empty).

Operations

RemoveHead Removes the element from the head of the list.
RemoveTail Removes the element from the tail of the list.
AddHead Adds an element (or all the elements in another list) to the head of the list (makes a new head).
AddTail Adds an element (or all the elements in another list) to the tail of the list (makes a new tail).
RemoveAll Removes all the elements from this list.

Iteration

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.

Retrieval/Modification

GetAt Gets the element at a given position.
SetAt Sets the element at a given position.
RemoveAt Removes an element from this list, specified by position.

Insertion

InsertBefore Inserts a new element before a given position.
InsertAfter Inserts a new element after a given position.

Searching

Find Gets the position of an element specified by pointer value.
FindIndex Gets the position of an element specified by a zero-based index.

Status

GetCount Returns the number of elements in this list.
IsEmpty Tests for the empty list condition (no elements).


（2）CList Class Members  Using Demo

Construction 
CList<int,int> myList;//建立一个int链表
CList<CString,CString&> myList(16);//建立一个cstring的链表，后面的16表示链表里面数据的个数
CList<MyType,MyType&> myList;//建立一个MYTYPE类型（自定义）的链表,如果不存入数据的话，刚建立的链表是空的，头尾都为空
 其它成员函数使用例子请点击该链接：成员函数使用例子


（3）源码

CPlex 
struct CPlex     // warning variable length structure
{
	CPlex* pNext;
#ifndef _WIN64
#if (_AFX_PACKING >= 8)
	DWORD dwReserved[1];    // align on 8 byte boundary
#endif
#endif
	// 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
};


/
// CPlex

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;
}

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;
	}
}

CList 
template<class TYPE, class ARG_TYPE>
BOOL AFXAPI CompareElements(const TYPE* pElement1, const ARG_TYPE* pElement2)
{
	ENSURE(pElement1 != NULL && pElement2 != NULL);
	ASSERT(AfxIsValidAddress(pElement1, sizeof(TYPE), FALSE));
	ASSERT(AfxIsValidAddress(pElement2, sizeof(ARG_TYPE), FALSE));

	return *pElement1 == *pElement2;
}

/
// CList<TYPE, ARG_TYPE>

template<class TYPE, class ARG_TYPE = const TYPE&>
class CList : public CObject
{
protected:
	struct CNode
	{
		CNode* pNext;
		CNode* pPrev;
		TYPE data;
	};
public:
// Construction
	/* explicit */ CList(INT_PTR nBlockSize = 10);

// Attributes (head and tail)
	// count of elements
	INT_PTR GetCount() const;
	INT_PTR GetSize() const;
	BOOL IsEmpty() const;

	// peek at head or tail
	TYPE& GetHead();
	const TYPE& GetHead() const;
	TYPE& GetTail();
	const TYPE& GetTail() const;

// Operations
	// get head or tail (and remove it) - don't call on empty list !
	TYPE RemoveHead();
	TYPE RemoveTail();

	// add before head or after tail
	POSITION AddHead(ARG_TYPE newElement);
	POSITION AddTail(ARG_TYPE newElement);

	// add another list of elements before head or after tail
	void AddHead(CList* pNewList);
	void AddTail(CList* pNewList);

	// remove all elements
	void RemoveAll();

	// iteration
	POSITION GetHeadPosition() const;
	POSITION GetTailPosition() const;
	TYPE& GetNext(POSITION& rPosition); // return *Position++
	const TYPE& GetNext(POSITION& rPosition) const; // return *Position++
	TYPE& GetPrev(POSITION& rPosition); // return *Position--
	const TYPE& GetPrev(POSITION& rPosition) const; // return *Position--

	// getting/modifying an element at a given position
	TYPE& GetAt(POSITION position);
	const TYPE& GetAt(POSITION position) const;
	void SetAt(POSITION pos, ARG_TYPE newElement);
	void RemoveAt(POSITION position);

	// inserting before or after a given position
	POSITION InsertBefore(POSITION position, ARG_TYPE newElement);
	POSITION InsertAfter(POSITION position, ARG_TYPE newElement);

	// helper functions (note: O(n) speed)
	POSITION Find(ARG_TYPE searchValue, POSITION startAfter = NULL) const;
		// defaults to starting at the HEAD, return NULL if not found
	POSITION FindIndex(INT_PTR nIndex) const;
		// get the 'nIndex'th element (may return NULL)

// Implementation
protected:
	CNode* m_pNodeHead;
	CNode* m_pNodeTail;
	INT_PTR m_nCount;
	CNode* m_pNodeFree;
	struct CPlex* m_pBlocks;
	INT_PTR m_nBlockSize;

	CNode* NewNode(CNode*, CNode*);
	void FreeNode(CNode*);

public:
	~CList();
	void Serialize(CArchive&);
#ifdef _DEBUG
	void Dump(CDumpContext&) const;
	void AssertValid() const;
#endif
};

/
// CList<TYPE, ARG_TYPE> inline functions

template<class TYPE, class ARG_TYPE>
INT_PTR CList<TYPE, ARG_TYPE>::GetCount() const
{ 
	return m_nCount; 
}

template<class TYPE, class ARG_TYPE>
INT_PTR CList<TYPE, ARG_TYPE>::GetSize() const
{ 
	return m_nCount; 
}

template<class TYPE, class ARG_TYPE>
BOOL CList<TYPE, ARG_TYPE>::IsEmpty() const
{
	return m_nCount == 0; 
}

template<class TYPE, class ARG_TYPE>
TYPE& CList<TYPE, ARG_TYPE>::GetHead()
{ 
	ENSURE(m_pNodeHead != NULL);
	return m_pNodeHead->data; 
}

template<class TYPE, class ARG_TYPE>
const TYPE& CList<TYPE, ARG_TYPE>::GetHead() const
{ 
	ENSURE(m_pNodeHead != NULL);
	return m_pNodeHead->data; 
}

template<class TYPE, class ARG_TYPE>
TYPE& CList<TYPE, ARG_TYPE>::GetTail()
{
	ENSURE(m_pNodeTail != NULL);
	return m_pNodeTail->data; 
}

template<class TYPE, class ARG_TYPE>
const TYPE& CList<TYPE, ARG_TYPE>::GetTail() const
{
	ENSURE(m_pNodeTail != NULL);
	return m_pNodeTail->data;
}

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::GetHeadPosition() const
{ 
	return (POSITION) m_pNodeHead; 
}

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::GetTailPosition() const
{ 
	return (POSITION) m_pNodeTail; 
}

template<class TYPE, class ARG_TYPE>
TYPE& CList<TYPE, ARG_TYPE>::GetNext(POSITION& rPosition) // return *Position++
{ 
	CNode* pNode = (CNode*) rPosition;
	ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
	rPosition = (POSITION) pNode->pNext;
	return pNode->data; 
}

template<class TYPE, class ARG_TYPE>
const TYPE& CList<TYPE, ARG_TYPE>::GetNext(POSITION& rPosition) const // return *Position++
{ 
	CNode* pNode = (CNode*) rPosition;
	ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
	rPosition = (POSITION) pNode->pNext;
	return pNode->data; 
}

template<class TYPE, class ARG_TYPE>
TYPE& CList<TYPE, ARG_TYPE>::GetPrev(POSITION& rPosition) // return *Position--
{ 
	CNode* pNode = (CNode*) rPosition;
	ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
	rPosition = (POSITION) pNode->pPrev;
	return pNode->data; 
}

template<class TYPE, class ARG_TYPE>
const TYPE& CList<TYPE, ARG_TYPE>::GetPrev(POSITION& rPosition) const // return *Position--
{ 
	CNode* pNode = (CNode*) rPosition;
	ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
	rPosition = (POSITION) pNode->pPrev;
	return pNode->data; 
}

template<class TYPE, class ARG_TYPE>
TYPE& CList<TYPE, ARG_TYPE>::GetAt(POSITION position)
{
	CNode* pNode = (CNode*) position;
	ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
		
	return pNode->data;
}

template<class TYPE, class ARG_TYPE>
AFX_INLINE const TYPE& CList<TYPE, ARG_TYPE>::GetAt(POSITION position) const
{ 
	CNode* pNode = (CNode*) position;
	ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
	return pNode->data; 
}

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::SetAt(POSITION pos, ARG_TYPE newElement)
{ 
	CNode* pNode = (CNode*) pos;
	ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
	pNode->data = newElement; 
}

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;
}

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

	// destroy elements
	CNode* pNode;
	for (pNode = m_pNodeHead; pNode != NULL; pNode = pNode->pNext)
		pNode->data.~TYPE();

	m_nCount = 0;
	m_pNodeHead = m_pNodeTail = m_pNodeFree = NULL;
	m_pBlocks->FreeDataChain();
	m_pBlocks = NULL;
}

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


/
// Node helpers
//
// Implementation note: CNode's are stored in CPlex blocks and
//  chained together. Free blocks are maintained in a singly linked list
//  using the 'pNext' member of CNode with 'm_pNodeFree' as the head.
//  Used blocks are maintained in a doubly linked list using both 'pNext'
//  and 'pPrev' as links and 'm_pNodeHead' and 'm_pNodeTail'
//   as the head/tail.
//
// We never free a CPlex block unless the List is destroyed or RemoveAll()
//  is used - so the total number of CPlex blocks may grow large depending
//  on the maximum past size of the list.
//

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)
	{
		// add another block
		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

	CList::CNode* pNode = m_pNodeFree;
	m_pNodeFree = m_pNodeFree->pNext;
	pNode->pPrev = pPrev;
	pNode->pNext = pNext;
	m_nCount++;
	ASSERT(m_nCount > 0);  // make sure we don't overflow

#pragma push_macro("new")
#undef new
	::new( (void*)( &pNode->data ) ) TYPE;
#pragma pop_macro("new")
	return pNode;
}

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::FreeNode(CNode* pNode)
{
	pNode->data.~TYPE();
	pNode->pNext = m_pNodeFree;
	m_pNodeFree = pNode;
	m_nCount--;
	ASSERT(m_nCount >= 0);  // make sure we don't underflow

	// if no more elements, cleanup completely
	if (m_nCount == 0)
		RemoveAll();
}

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::AddHead(ARG_TYPE newElement)
{
	ASSERT_VALID(this);

	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;
}

template<class TYPE, class ARG_TYPE>
POSITION CList<TYPE, ARG_TYPE>::AddTail(ARG_TYPE newElement)
{
	ASSERT_VALID(this);

	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;
}

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::AddHead(CList* pNewList)
{
	ASSERT_VALID(this);

	ENSURE(pNewList != NULL);
	ASSERT_VALID(pNewList);

	// add a list of same elements to head (maintain order)
	POSITION pos = pNewList->GetTailPosition();
	while (pos != NULL)
		AddHead(pNewList->GetPrev(pos));
}

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::AddTail(CList* pNewList)
{
	ASSERT_VALID(this);
	ENSURE(pNewList != NULL);
	ASSERT_VALID(pNewList);

	// add a list of same elements
	POSITION pos = pNewList->GetHeadPosition();
	while (pos != NULL)
		AddTail(pNewList->GetNext(pos));
}

template<class TYPE, class ARG_TYPE>
TYPE CList<TYPE, ARG_TYPE>::RemoveHead()
{
	ASSERT_VALID(this);
	ENSURE(m_pNodeHead != NULL);  // don't call on empty list !!!
	ASSERT(AfxIsValidAddress(m_pNodeHead, sizeof(CNode)));

	CNode* pOldNode = m_pNodeHead;
	TYPE returnValue = pOldNode->data;

	m_pNodeHead = pOldNode->pNext;
	if (m_pNodeHead != NULL)
		m_pNodeHead->pPrev = NULL;
	else
		m_pNodeTail = NULL;
	FreeNode(pOldNode);
	return returnValue;
}

template<class TYPE, class ARG_TYPE>
TYPE CList<TYPE, ARG_TYPE>::RemoveTail()
{
	ASSERT_VALID(this);
	ENSURE(m_pNodeTail != NULL);  // don't call on empty list !!!
	ASSERT(AfxIsValidAddress(m_pNodeTail, sizeof(CNode)));

	CNode* pOldNode = m_pNodeTail;
	TYPE returnValue = pOldNode->data;

	m_pNodeTail = pOldNode->pPrev;
	if (m_pNodeTail != NULL)
		m_pNodeTail->pNext = NULL;
	else
		m_pNodeHead = NULL;
	FreeNode(pOldNode);
	return returnValue;
}

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

	if (position == NULL)
		return AddHead(newElement); // insert before nothing -> head of the list

	// Insert it before position
	CNode* pOldNode = (CNode*) position;
	CNode* pNewNode = NewNode(pOldNode->pPrev, pOldNode);
	pNewNode->data = newElement;

	if (pOldNode->pPrev != NULL)
	{
		ASSERT(AfxIsValidAddress(pOldNode->pPrev, sizeof(CNode)));
		pOldNode->pPrev->pNext = pNewNode;
	}
	else
	{
		ASSERT(pOldNode == m_pNodeHead);
		m_pNodeHead = pNewNode;
	}
	pOldNode->pPrev = pNewNode;
	return (POSITION) pNewNode;
}

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

	if (position == NULL)
		return AddTail(newElement); // insert after nothing -> tail of the list

	// Insert it before position
	CNode* pOldNode = (CNode*) position;
	ASSERT(AfxIsValidAddress(pOldNode, sizeof(CNode)));
	CNode* pNewNode = NewNode(pOldNode, pOldNode->pNext);
	pNewNode->data = newElement;

	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;
}

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);
}

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;
	while (nIndex--)
	{
		ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
		pNode = pNode->pNext;
	}
	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;
}

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::Serialize(CArchive& ar)
{
	ASSERT_VALID(this);

	CObject::Serialize(ar);

	if (ar.IsStoring())
	{
		ar.WriteCount(m_nCount);
		for (CNode* pNode = m_pNodeHead; pNode != NULL; pNode = pNode->pNext)
		{
			ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
			TYPE* pData;
			/* 
			 * in some cases the & operator might be overloaded, and we cannot use it to obtain
			 * the address of a given object.  We then use the following trick to get the address
			 */
			pData = reinterpret_cast< TYPE* >( &reinterpret_cast< int& >( static_cast< TYPE& >( pNode->data ) ) );
			SerializeElements<TYPE>(ar, pData, 1);
		}
	}
	else
	{
		DWORD_PTR nNewCount = ar.ReadCount();
		while (nNewCount--)
		{
			TYPE newData[1];
			SerializeElements<TYPE>(ar, newData, 1);
			AddTail(newData[0]);
		}
	}
}

#ifdef _DEBUG
template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::Dump(CDumpContext& dc) const
{
	CObject::Dump(dc);

	dc << "with " << m_nCount << " elements";
	if (dc.GetDepth() > 0)
	{
		POSITION pos = GetHeadPosition();
		while (pos != NULL)
		{
			TYPE temp[1];
			temp[0] = ((CList*)this)->GetNext(pos);
			dc << "\n";
			DumpElements<TYPE>(dc, temp, 1);
		}
	}

	dc << "\n";
}

template<class TYPE, class ARG_TYPE>
void CList<TYPE, ARG_TYPE>::AssertValid() const
{
	CObject::AssertValid();

	if (m_nCount == 0)
	{
		// empty list
		ASSERT(m_pNodeHead == NULL);
		ASSERT(m_pNodeTail == NULL);
	}
	else
	{
		// non-empty list
		ASSERT(AfxIsValidAddress(m_pNodeHead, sizeof(CNode)));
		ASSERT(AfxIsValidAddress(m_pNodeTail, sizeof(CNode)));
	}
}
#endif //_DEBUG

参考链接： CList成员函数
                 Demo



舟山群岛
关注
MFC CList 类的使用
bcbobo21cn的专栏
07-26 1179
MFC CList类支持可按顺序或按值访问的非唯一对象的有序列表；
Clist的使用
04-21
在vc6.0上使用CList,使用了Clist的多个成员函数，比较适合初学者使用
CList 类
03-14 1397
导读： 　　CList 类 　　C++中实现通用数据结构 　　在程序设计当中经常会出现使用同种数据结构的不同实例的情况。例如:在一个 　　程序中可以使用多个队列、树、图等结构来组织数据。同种结构的不同实例,也 　　许只在数据元素的类型或数量上略有差异,如果对每个实例都重新定义,则非常麻 　　烦且容易出错。那么能否对同种类型数据结构仅定义一次呢?答案是肯定的,C++ 　　提供的类模板(Cla
List.h
04-09 157
/* // CList类的成员 // // 构造函数 CList 构造一个空的有序列表 // // 标题/末尾访问 GetHead 返回列表的标题元素（不能为空） // GetTail 返回列表的末尾元素（不能为空） // // 操作 RemoveHead 从列表标题中移走元素 // RemoveTail 从列表末尾移走元素 // AddHead 添加一个元素（或另一个列表的所有元素）到列表标题（生成新的标题） // AddTail 添加一个元素（或另一个列表的所有元素）到列表...
CList
cslie的专栏
06-26 378
头文件 #include <cstdio> #include <afxtempl.h> 代码 // 源代码POSITION定义 ，一个结构指针 //struct __POSITION {}; //typedef __POSITION* POSITION; //源代码节点定义 ，双向链表 //struct CNode //{ // CNode* pNext; // CNode* pPrev; // TYPE data; //}; CLis.
CList类
热门推荐
zhoubl668的专栏：远帆，梦之帆！
02-10 1万+
MFC中CList类使用注意    初学mfc者，往往对CList等mfc的Collect类的使用感到迷惑，在使用中经常会遇到许多问题，导致对vc中的Collect类的使用产生了惧怕。以下，就个人经历而言,告诉大家如何使用CList。CList是一个双向链表类。1、头文件名不可少Clist类定义在Afxtempl.h 头文件中，因此在使用该类时，需要加这个头文件名。2、理解CList的声明和构
一个通用链表类
水妖的专栏
02-17 2242
链表是必不可少的数据结构，很多运行时库都提供了现成的链表类。当然我们也可以自己实现它。下面就是一个例子。类的定义如下：//****************************************************************************//// CLASS COBLIST DEFINATION////******************************
MFC中CList类使用注意
ellor的专栏
07-29 3960
初学mfc者，往往对CList等mfc的Collect类的使用感到迷惑，在使用中经常会遇到许多问题，导致对vc中的Collect类的使用产生了惧怕。以下，就个人经历而言,告诉大家如何使用CList。CList是一个双向链表类。1、头文件名不可少Clist类定义在Afxtempl.h 头文件中，因此在使用该类时，需要加这个头文件名。2、理解CList的声明和构造方法CList
MFC CList 链表 排序，源码实现，已验证，VC++
06-11
本篇文章将深入探讨如何使用源码实现`CList`的排序功能，并结合提供的`ClistSort.cpp`和`ClistSort.h`文件进行解析。 首先，我们需要了解`CList`的基本操作。`CList` 提供了插入、删除、遍历等方法，如`AddHead()`,...
标准库list源码
03-24
学习STL源码的好助手，是一个非常简化版的SLT list源码，可以让你理解stl的本质
CList的使用
07-16
是一个MFC小程序 点击窗口 移动放开鼠标 记录两点 存入链表 点击回车键取出链表元素并画直线
MFC实现动态数据趋势划线功能源码解析
在MFC程序中，通常会使用CArray或CList等MFC集合类来存储这些数据点。 接着，需要考虑的是如何在界面上绘制这些数据点，并动态地将它们以线段连接起来。MFC中提供了CDC类，通过它的绘图函数，如MoveTo、LineTo等...
链表驱动读取Excel多字段数据：实例与源码解析
本篇文章主要介绍了如何使用链表类（CList,NAME&>）来处理Excel表格中的多字段数据，特别是当需要将数据存储为一个名为NAME的类的对象时。标题中提到的“创建节点”实际上是指在程序中定义一个结构体或类（NAME），...
MFC实现贪吃蛇小游戏：界面设计与源码解析
可能使用CArray或CList等MFC容器类来实现。 8. **算法**: 游戏的关键算法包括蛇的移动逻辑（避免碰撞）、食物的生成逻辑（随机位置）以及游戏结束条件的判断。 9. **绘图函数**: 利用CDC类提供的绘图函数，如Move...
Android10.0 Service绑定源码解析
门心叼龙的专栏
11-16 4948
我们知道Service有两种启动模式一种是startService，另一种是bindService，通过startService启动后Activity和Service就没有任何关系了，当Activity销毁了，Service可以在后台依然存活，而通过bindService启动后Activity和Service的生命周期就捆绑在了一起，当Activity销毁了Service也就销毁了，这两种用法各有...
CLIST
yuwei19840916的专栏
12-03 583
CList类的两个参数什么意思啊？第一个参数表示链表中存储的数据类型，后面一个表示链表类中函数参数的传递方式，通常为存储数据类型的引用。CList MyList_x;CListMyList_y;//两种方式实现的功能一样，不过后面一个更加高效。CList list;声明方式就是错误，CList list1;CList list2;CList list3;都是可以接受的声明方式。
CList类库
qq_38611124的博客
07-01 1140
新建一个win32控制台应用程序（CList是MFC的类库，STL是标准类库，所有c++都有）CStudent.h的内容#include&lt;afxtempl.h&gt; typedef struct Student { char name[20]; int number; }student; class CStudent { public: CStudent(); void St...
MFC CList链表自定义排序功能实现教程
尽管MFC库已经提供了一些基本的数据结构支持，但它并没有直接为CList类提供排序功能，这意味着开发者需要自行实现排序算法，或者通过其他方式来对CList中的元素进行排序。 #### CList使用要点 CList作为模板类，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值