可串行化排序动态对象数组的VC实现

VC6.0里面的CObArray以及基于它的模板数组都支持串行化Serialize,但是遗憾的是不支持排序,本文给出一个可排序并也支持对象串行化的动态对象数组类CSorObtArray。

排序采用qsort快速排序，用一个对象CSortObject作为基类，凡是从CSortObject派生而来的类都可加入CSortObArray对象，重载CSortObject::Compare()可实现对象的快速排序,重载CSortObject::Serialize()可实现对象的串行化。CSortObject和CSortObArray的关系如同VC中CObject和CObArray的关系。

1、SortObArray.h

// SortObArray.h 带排序的对象
// 
#pragma once
class CSortObject    :    public CObject //排序对象基类
{
protected:
    DECLARE_SERIAL(CSortObject);
public:
    CSortObject();
    virtual            ~CSortObject();
    virtual void    Serialize(CArchive& ar);

    void            SetSortAsc(BOOL bAsc);//设置排序方式
    virtual        int Compare(CSortObject *pOb);//排序比较,bASC是升序
protected:
    BOOL        m_bAsc;//升序
};

typedef CSortObject *LPSORTOB;//类型定义

class CSortObArray : public CObject//排序对象动态数组
{
protected:
    DECLARE_SERIAL(CSortObArray);
public:
    CSortObArray();
    ~CSortObArray();//析构只删除空间，不删除对象

    virtual void    Serialize(CArchive& ar);//串行化，已有的对象会被删除掉

public:
    BOOL        Add(LPSORTOB pOb);//添加
    int            GetSize();//取当前对象个数
    LPSORTOB    GetAt(int nIndex);//取一个对象

    void        RemoveAll();//清除空间并重新初始化 ，不删除对象
    LPSORTOB    RemoveAt(int nIndex);//移除对象，不删除初对象，返回被移除的对象
    void        DeleteObjects();//删除所有对象
    void        Qsort(BOOL bAsc);//快速排序

protected:
    LPSORTOB    *m_ob;//对象数组
    int            m_nMaxSize;
    int            m_nSize;
    int            m_nGrown;//每次增量
    
    static int  Comp(const void *p1,const void *p2 );
    BOOL        Grown();//增长
};

class CSortTestOb : public CSortObject//排序测试对象
{
protected:
    DECLARE_SERIAL(CSortTestOb);
public:
    CSortTestOb();
    CSortTestOb(int ndata);
    
    int            m_ndata;

    virtual            ~CSortTestOb();
    virtual void    Serialize(CArchive& ar);
    virtual    int        Compare(CSortObject *pOb);//排序比较,bASC是升序
};  

2、SortObArray.cpp

// SortObArray.cpp
#include "stdafx.h"
#include "SortObject.h"

IMPLEMENT_SERIAL(CSortObject, CObject, 0)

CSortObject::CSortObject()
{
}
CSortObject::~CSortObject()
{
}

void    CSortObject::Serialize(CArchive& ar)
{
    CObject::Serialize(ar);
}

void    CSortObject::SetSortAsc(BOOL bAsc)
{
    m_bAsc = bAsc;
}

int CSortObject::Compare(LPSORTOB pOb)//排序比较,bASC是升序,基类比较无意义，请重载使用
{
    if(m_bAsc)
        return -1;
    else
        return 1;
}

//////////////////////////////////////////////////////////////////////////////
IMPLEMENT_SERIAL(CSortObArray, CObject, 0)

CSortObArray::CSortObArray()
{
    m_ob = NULL;
    m_nMaxSize = 0;
    m_nSize = 0;
    m_nGrown = 1024;
}

CSortObArray::~CSortObArray()
{
    if(m_ob)
        free(m_ob);
}

void    CSortObArray::Serialize(CArchive& ar)
{
    CObject::Serialize(ar);

    if(ar.IsStoring())//存储
    {
        ar.WriteCount(m_nSize);
        for(int i=0;i<m_nSize;i++)
            ar << m_ob[i];
    }
    else
    {
        int nsize=0;
        CSortObject *pob;

        DeleteObjects();//删除原来对象

        nsize = ar.ReadCount();
        while (nsize--)
        {
            ar >> pob;
            Add(pob);
        }
    }
}

BOOL    CSortObArray::Grown()//增长
{
    LPSORTOB *ob = NULL;
    ob = (LPSORTOB *)malloc((m_nMaxSize + m_nGrown) * sizeof(LPSORTOB));//分配初始空间
    
    if(ob == NULL)
        return FALSE;

    m_nMaxSize += m_nGrown;

    if(m_ob == NULL)
    {
        m_ob = ob;
        return TRUE;
    }
    
    int i;
    for(i=0;i<m_nSize;i++)
        ob[i] =  m_ob[i];//复制
    
    while(i < m_nMaxSize)//多余的清零
    {
        ob[i] = NULL;
        i++;
    }
    free(m_ob);//清除旧的
    m_ob = ob;//保存新的
    return TRUE;
}

void CSortObArray::RemoveAll()//移除所有对象，不删除对象
{
    if((m_ob == NULL)||(m_nSize == 0))
        return;
    
    for(int i=0;i< m_nMaxSize;i++)
        m_ob[i] = NULL;

    m_nSize = 0;
}

void    CSortObArray::DeleteObjects()//删除所有对象
{
    if((m_ob == NULL)||(m_nSize == 0))
        return;
    for(int i=0;i< m_nSize;i++)
    {
        delete m_ob[i];
        m_ob[i] = 0;
    }
    m_nSize = 0;
}

LPSORTOB    CSortObArray::RemoveAt(int nIndex)//移除对象，不删除初对象，返回被移除的对象
{
    if((m_ob == NULL)||(m_nSize == 0))
        return NULL;

    if((nIndex < 0)||(nIndex >= m_nSize))
        return NULL;

    LPSORTOB pob = m_ob[nIndex];
    if(nIndex  == m_nSize - 1)
    {
        m_ob[nIndex] = NULL;
        m_nSize--;
        return pob;
    }
    
    for(int i=nIndex;i<m_nSize-1;i++)
        m_ob[i] = m_ob[i+1];

    m_ob[i] = NULL;
    m_nSize--;

    return pob;
}

int        CSortObArray::GetSize()//取当前对象个数
{
    return m_nSize;
}

LPSORTOB CSortObArray::GetAt(int nIndex)//取一个对象
{
    if((m_ob == NULL)||(m_nSize == 0))
        return NULL;
    if((nIndex >=0) &&(nIndex <m_nSize))
        return m_ob[nIndex];
    return NULL;
};

BOOL CSortObArray::Add(LPSORTOB pOb)//添加
{
    if(m_nSize < m_nMaxSize)
    {
        m_ob[m_nSize] = pOb;
        m_nSize++;
        return TRUE;
    }
    if(!Grown())
        return FALSE;
    m_ob[m_nSize] = pOb;
    m_nSize++;
    return TRUE;
}

int CSortObArray::Comp(const void *p1,const void *p2 )
{
    LPSORTOB pi1 ,pi2;
    pi1 = (LPSORTOB)(*((LPSORTOB *)p1));
    pi2 = (LPSORTOB)(*((LPSORTOB *)p2));

    return pi1->Compare(pi2);
};


void  CSortObArray::Qsort(BOOL bAsc)//排序
{
    if((m_ob == NULL)||(m_nSize == 0))
        return ;
    for(int i=0;i<m_nSize;i++)
        m_ob[i]->SetSortAsc(bAsc);
    qsort(m_ob, m_nSize,sizeof(LPSORTOB),Comp);
}

//------------------------------------------------------
IMPLEMENT_SERIAL(CSortTestOb,CSortObject, 0)

CSortTestOb::CSortTestOb()
{
    m_ndata = 0;
}

CSortTestOb::CSortTestOb(int ndata)
{
    m_ndata = ndata;
}

CSortTestOb::~CSortTestOb()
{

}

void CSortTestOb::Serialize(CArchive& ar)
{
    CSortObject::Serialize(ar);

    if(ar.IsStoring())
        ar << m_ndata;
    else
        ar >> m_ndata;
}

int CSortTestOb::Compare(CSortObject *pOb)//排序比较,bASC是升序
{
    CSortTestOb *pob = (CSortTestOb*)pOb;

    int nret = 0;
    if(m_ndata < pob->m_ndata)
        nret = -1;
    else if(m_ndata > pob->m_ndata)
        nret = 1;
    else
        nret = 0;
    
    if(!m_bAsc)
        nret *= -1;

    return nret;
}

3、测试代码

void test()
{
    //测试排序对象
    CSortObArray sao;
    int i;
    CSortTestOb *pob;
    for(i=0;i<100;i++)
    {
        pob = new CSortTestOb(i);//升序加入
        sao.Add(pob);
    }
    sao.Qsort(FALSE);//降序排序

    //串行化测试
    CMemFile file;
    CArchive ar(&file, CArchive::store);//存入
    sao.Serialize(ar);
    ar.Close();

    
    file.SeekToBegin();
    CArchive arr(&file, CArchive::load);//读出
    sao.Serialize(arr);
    arr.Close();

    //查看结果
    for(i=0;i<sao.GetSize();i++)
    {
        TRACE("%d\n",((CSortTestOb *)(sao.GetAt(i)))->m_ndata);
    }

    sao.DeleteObjects();//删除对象
}

2008.10.12 蒋勇 www.kipway.com