zz CList的用法

最新推荐文章于 2015-06-12 17:46:00 发布
最新推荐文章于 2015-06-12 17:46:00 发布
阅读量1.6k 收藏 3
点赞数
文章标签： class null construction string attributes struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/greenbamboocsu/article/details/1703290
版权

from：

1 http://hi.baidu.com/jiaxi2000/blog/item/d3d02b3f3b1f6aee54e72381.html

CList的用法
2007-06-21 09:26

这是一个集合类，也是一个双向链表类，是一个类模板　
他的定义如下：
template< class TYPE , class ARG_TYPE >class CList : public CObject
使用
第一个参数是实例化的类型，第二个参数是类的成员函数的参数的调用形式，通常是类型　引用
一个矩形类Rectangle的类模板：
template  < class  T >   class  Rectangle
   {
     private:
              T width, height;
     public:
              Rectangle(T w, T h); //构造函数
              T  area();
} ;
 在类中，形参T被引用在数据成员width和height的类型及成员函数area返回值的类型上，它是根据将来
程序中声明时指定的类型而定，如在主程序中声明：
Rectangle<int> r1(20,3);
则类模板中的形参T会以int替代，产生以整数为主的Rectangle对象r1 ；
另外，成员函数如果 设计在类外，除了要标明其所属的类名称外，还需要加上模板的声明，且类名称也要加上用
尖括号括起来的形参行。如上例中的成员函数Rectangle(T w, T h)和area(),其写法如下：
template  < class  T >  Rectangle < T >  ::Rectangle(T w,T h)
 {
 width = w;
 height = h;
}

template  < class  T >  T Rectangle < T > ::area()
 {
 return width*height;
}
--------------
具有固定类型的类模板
类模板的形参行，不仅可以使用未定类型的类，也可指定固定的类型，如下：
template  < class  T,  int  n >   class  Array {
 private:
     T data[n];
 public:
Array(){}                                                //构造函数
void add_data(int i, T d);                      //将数据填入数组中
Array<T,n > operator+(Array<T,n> a);   //数组相加
void display();
} ;
如使用这类模板时，如下：
Array<double, 3> dbl1;
表示声明了一个Array对象，其中的数据是double类型，且其数组大小为3，其作用相当于声明了
double data[3].
=================
Afxtempl.h 中的CList
//  CList<TYPE, ARG_TYPE>

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

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

    // peek at head or tail
    TYPE& GetHead();
    TYPE GetHead() const;
    TYPE& GetTail();
    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++
    TYPE GetNext(POSITION& rPosition) const; // return *Position++
    TYPE& GetPrev(POSITION& rPosition); // return *Position--
    TYPE GetPrev(POSITION& rPosition) const; // return *Position--

    // getting/modifying an element at a given position
    TYPE& GetAt(POSITION position);
    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 nIndex) const;
        // get the 'nIndex'th element (may return NULL)

// Implementation
protected:
    CNode* m_pNodeHead;
    CNode* m_pNodeTail;
    int m_nCount;
    CNode* m_pNodeFree;
    struct CPlex* m_pBlocks;
    int 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 >
AFX_INLINE  int  CList < TYPE, ARG_TYPE > ::GetCount()  const
     { return m_nCount; }
template < class  TYPE,  class  ARG_TYPE >
AFX_INLINE BOOL CList < TYPE, ARG_TYPE > ::IsEmpty()  const
     { return m_nCount == 0; }
template < class  TYPE,  class  ARG_TYPE >
AFX_INLINE TYPE &  CList < TYPE, ARG_TYPE > ::GetHead()
     { ASSERT(m_pNodeHead != NULL);
        return m_pNodeHead->data; }
template < class  TYPE,  class  ARG_TYPE >
AFX_INLINE TYPE CList < TYPE, ARG_TYPE > ::GetHead()  const
     { ASSERT(m_pNodeHead != NULL);
        return m_pNodeHead->data; }
template < class  TYPE,  class  ARG_TYPE >
AFX_INLINE TYPE &  CList < TYPE, ARG_TYPE > ::GetTail()
     { ASSERT(m_pNodeTail != NULL);
        return m_pNodeTail->data; }
template < class  TYPE,  class  ARG_TYPE >
AFX_INLINE TYPE CList < TYPE, ARG_TYPE > ::GetTail()  const
     { ASSERT(m_pNodeTail != NULL);
        return m_pNodeTail->data; }
template < class  TYPE,  class  ARG_TYPE >
AFX_INLINE POSITION CList < TYPE, ARG_TYPE > ::GetHeadPosition()  const
     { return (POSITION) m_pNodeHead; }
template < class  TYPE,  class  ARG_TYPE >
AFX_INLINE POSITION CList < TYPE, ARG_TYPE > ::GetTailPosition()  const
     { return (POSITION) m_pNodeTail; }
template < class  TYPE,  class  ARG_TYPE >
AFX_INLINE 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 >
AFX_INLINE 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 >
AFX_INLINE 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 >
AFX_INLINE 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 >
AFX_INLINE 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 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 >
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; }

template < class  TYPE,  class  ARG_TYPE >
CList < TYPE, ARG_TYPE > ::CList( int  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)
        DestructElements<TYPE>(&pNode->data, 1);

    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 >
CList < TYPE, ARG_TYPE > ::CNode *
CList < TYPE, ARG_TYPE > ::NewNode(CList::CNode *  pPrev, CList::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 i = m_nBlockSize-1; i >= 0; i--, pNode--)
        {
            pNode->pNext = m_pNodeFree;
            m_pNodeFree = pNode;
        }
    }
    ASSERT(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

    ConstructElements<TYPE>(&pNode->data, 1);
    return pNode;
}

template < class  TYPE,  class  ARG_TYPE >
void  CList < TYPE, ARG_TYPE > ::FreeNode(CList::CNode *  pNode)
 {
    DestructElements<TYPE>(&pNode->data, 1);
    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);

    ASSERT(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);
    ASSERT(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);
    ASSERT(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);
    ASSERT(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  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)));
            SerializeElements<TYPE>(ar, &pNode->data, 1);
        }
    }
    else
    {
        DWORD nNewCount = ar.ReadCount();
        while (nNewCount--)
        {
            TYPE newData;
            SerializeElements<TYPE>(ar, &newData, 1);
            AddTail(newData);
        }
    }
}

#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)
        {
            dc << " ";
            DumpElements<TYPE>(dc, &((CList*)this)->GetNext(pos), 1);
        }
    }

    dc << " ";
}

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
=========================
因此如下：
typedef CList<CString ,CString &> strlist;
strlist str;
or
CList<CString ,CString &> str;
这样就定义了一个ＣＳｔｒｉｎｇ类型的双向链表str;
这样可以看出 ARG_TYPE主要指定 CList的方法对于TYPE的引用方法。  
   
  例如：  
  1)  
  CList<string,   string>   list;  
  POSITION   AddHead(string   newElement);  
  这是AddHead参数为 传值  
   
  2)  
  CList<string,   string&>   list;  
  POSITION   AddHead(string&   newElement);  
  这是AddHead参数为传 引用  
 

greenbamboocsu
关注
在项目中对CList Ctrl的学习
bluelambo的专栏
09-14 3718
　　计算机资源管理项目中需要在主窗口中使用一个Ｃｌｉｓｔ　ＣＴＲＬ来显示所有的计算机资源。下面是对ＣＬｉｓｔ　ＣＴＲＬ学习的笔记（ＺＺ），以满足显示上的需求。（一）列表控制的主要功能　　列表控制和视（List Control&View)主要用来以各种方式显示一组数据记录供用户进行各种操作，Windows98/95中资源管理器中的“查看”标签下的“大图标｜小图标｜列表｜详细资源”就是一个非常好的典型
VC中CList用法及其成员的使用
08-12
"VC 中 CList 用法及其成员的使用" CList 是 MFC 中的一个双向链表类，主要用于存储和管理大量数据。下面，我们将详细介绍 CList 的用法及其成员的使用。 头文件名不可少 CList 类定义在 Afxtempl.h 头文件中，...
MFC集合类之CList
imxiangzi的专栏
10-03 1810
之前我们先以CStringList为例演示下列成员方法： AddTail, AddHead, GetHeadPosition, GetTailPosition, GetPrev(), GetNext() 我们看到如何向一个CList类中增加数据：可以从两端增加，以及如何遍历整个CList……   [cpp] view plaincopy
zz MFC 的CList，CPtrList，CObList，CStringList 的用法
07-23 595
from http://blog.csdn.net/guanchanghui/archive/2006/09/16/1232109.aspx 一直在编程中使用stl进行编程，但是最近感觉微软提供的模版类也是很好，出错机率更低，建议在mfc的工程使用。相关介绍如下，参照msdn搞清接口即可使用CList是通用型的列表类，你可以存放指定的数据类型，用法如下：CList list;这样就指定了C
[ZZ] C++ list
WayneChen1993的博客
06-12 134
双向循环链表list list是双向循环链表，，每一个元素都知道前面一个元素和后面一个元素。在STL中，list和vector一样，是两个常被使用的容器。和vector不一样的是，list不支持对元素的任意存取。list中提供的成员函数与vector类似，不过list提供对表首元素的操作push_front、pop_front，这是vector不具备的。和vector另...
[zz]使用 Python 为 KVM 编写脚本，第 1 部分: libvirt
weixin_33755554的博客
02-28 259
Paul Ferrill, CTO, ATAC   简介： 本系列文章由两部分组成，将探讨如何使用 Python 创建脚本，用这些脚本管理使用 KVM 的虚拟机。在这一期文章中，我们将学习使用 libvirt 和 Python 绑定来构建一些简单状态和显示工具的基础知识。 本文的标签：  python, python实例, resource_virtualization ...
C++中vector的用法
sevedk的专栏
06-06 668
参考连接: http://www.cplusplus.com/reference/vector/vector/
【ZZ 】【编著】【技术专题】信号机制（全文）
a278002424的博客
03-13 190
Qt用预编译器和宏来保证强大的跨平台能力，信号机制则是其中最精妙之处。本文分析了几种常见的信号处理机制，然后详细介绍了Qt的Signal/Slot机制。 关键词：信号机制Signal/Slot Win32 MFC Linux Qt 首先要说明，这里所说的信号不是Unix中进程间通信的信号。这里的信号更多地与图形界面的输入输出联系在一起（当然也可以是不可见的操作）。自从计算机程序从字符...
[zz]STL标准模板类库-LIST的使用
ciyuan0857的博客
01-09 93
list 的使用在使用list必须包括头文件#include ，1)、如何定义一个list对象#include int main (void){ list cList; //声明了list模板类 的一个实例}2)、使用list的...
VC中CList用法及其成员的使用[参考].pdf
10-20
本文将详细介绍CList的用法及其成员的使用，帮助初学者理解和掌握这一工具。 CList类定义在`Afxtempl.h`头文件中，所以在使用CList之前，必须包含这个头文件。CList是一个模板类，它接受两个模板参数：`TYPE`和`ARG...
CList的使用
07-16
3. **处理鼠标消息**：在消息映射中处理`WM_LBUTTONDOWN`和`WM_LBUTTONUP`消息，获取鼠标点击的坐标，并使用`CList`的`AddTail`或`AddHead`方法添加到链表中。 4. **记录位置**：在鼠标释放时，保存两个点的位置。 5...
MATLAB实现基于SVM-RFE-BP多输入单输出回归预测（含完整的程序和代码详解）
10-18
内容概要：本文介绍了使用 MATLAB 实现基于支持向量机（SVM）、递归特征消除（RFE）和反向传播（BP）神经网络的多输入单输出回归预测模型。项目特点包括特征选择、BP神经网络建模、用户友好界面、模型评估机制以及超参数调整。文章详细描述了数据预处理、特征选择、模型训练、评估和可视化的步骤，并提供相应的 MATLAB 代码。 适合人群：具有一定编程基础的科研人员和工程技术人员，特别是从事数据科学、机器学习领域的研究人员。 使用场景及目标：适用于金融预测、疾病预测、工业生产监控和生态环境监测等领域，目的是提高数据预测的准确性。通过项目实战，学习特征选择和神经网络建模的技术细节。 其他说明：文中提到的相关代码示例和实现步骤可直接应用于实际项目中，有助于快速搭建高效的预测模型。同时，通过调整超参数和特征选择方法，可以进一步优化模型的性能。
rhino grasshoper 景观椅（附视频）.gh
最新发布
10-18
【rhino@grasshoper 曲线金属座椅景观案例（文件获取/见简介）】https://www.bilibili.com/video/BV1Dx4y147Lr?vd_source=b420114c993138474d2e93d83ead77a5
基于vercel的无服务器服务，将Spark认知模型连接到微信公众号_Spark微信vercel.zip
10-18
基于vercel的无服务器服务，将Spark认知模型连接到微信公众号_Spark微信vercel
中国大机型能力评价榜：目前已有115款大机型入选，涵盖chatgpt、gpt4o、百
10-18
中国大机型能力评价榜：目前已有115款大机型入选，涵盖chatgpt、gpt4o、百度文心一言、阿里巴巴通易千问、科大飞星火、商汤SenseChat、minimax等商业机型，以及百川、qwen2、glm
《动手学LLMs：实用编程教程系列》.zip
10-18
《动手学LLMs：实用编程教程系列》
在Disclosure Easy网站上抓取香港上市公司年报PDF文件并下载.zip
10-18
在Disclosure Easy网站上抓取香港上市公司年报PDF文件并下载
CList类实例教程与方法使用演示
由于给定的描述中提到，该资源包含了每一个方法的使用实例，因此可以预期在该CList.zip压缩包中会有详尽的代码示例和注释，以指导学习者如何正确地实现和调用CList类的各个方法。这样的资源对于初学者来说非常宝贵，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值