希望大家来评价评价我的编程风格
// CSortTest.h// 提供专用于测试排序函数性能的接口
////////////////////////////////////////////////////////////
#ifndef CSortTest_HEADER
#define CSortTest_HEADER
#include <time.h>
#include <cstdio>
#include <cassert>
#include <cstdlib>
// 测试的状态信息
struct TestInfo
{
int nTimeCost; // 排序时间开销
int nCountCmp; // 数据比较次数
int nCountDlv; // 数据赋值次数
};
// 自动生成数据的方式
#define LA_RAND 0 // 随机生成
#define LA_MOST_ASC 1 // 基本顺序
#define LA_MOST_DSC 2 // 基本逆序
const size_t ORDERED_DENSITY = 10; // 基本有序时的数据密度(两两间的平均距离)
const float ORDERED_DEGREE = 80; // 基本有序时的有序程度(有序部分所占的百分比)
// 专用测试的数据类型声明
class DataType;
// 排序函数名标准形式
typedef void (*SortFunction)(DataType [] ,unsigned);
// 专用测试的数据类型定义
class DataType
{
public:
DataType() {}
DataType(const int& tData) : m_tData(tData) { }
~DataType(){}
public:
operator int() const
{
return m_tData;
}
bool operator > (const DataType& other) const
{
DataType::s_nCountCmp++;
return m_tData > other.m_tData;
}
bool operator < (const DataType& other) const
{
DataType::s_nCountCmp++;
return m_tData < other.m_tData;
}
DataType& operator = (int tData)
{
m_tData = tData;
return *this;
}
DataType& operator = (const DataType& other)
{
DataType::s_nCountDlv++;
m_tData = other.m_tData;
return *this;
}
public:
// 测试状态信息，注意：每次测试前必须清零
static int s_nCountCmp; // 数据比较次数
static int s_nCountDlv; // 数据赋值次数
private:
int m_tData;
};
// 测试类**************************************************************************
// 专用于测试排序函数的类
class CSortTest
{
public:
CSortTest() { m_pSrcData = NULL; }
~CSortTest(){ delete [] m_pSrcData; }
public:
// 启动测试
void BeginTest(SortFunction fnSort,TestInfo* pInfo) const;
// 加载数据
bool LoadFrom(char* szFilename); // 从文件加载
void LoadFrom(const int* pData,size_t nCount); // 从内存加载
bool LoadAuto(size_t nCount,size_t nMethod); // 自动加载，nMethod为自动生成数据的方式
private:
DataType* m_pSrcData; // 包装后的数据数组
int m_nCountData; // 数组长度
};
#endif
// CSortTest.cpp
// 排序类的实现
/////////////////////////////////////////////////////////////////
#include "CSortTest.h"
#define VOID_NAMESPACE_BEGIN namespace {
#define VOID_NAMESPACE_END }
// 静态数据成员的初始化
int DataType::s_nCountCmp = 0;
int DataType::s_nCountDlv = 0;
// 排序测试类的实现***************************************
// 调试模式下用于测试数据状态的输出函数
#ifdef _DEBUG
void print(DataType* p,int n)
{
DataType* pEnd = p + n;
while(p < pEnd)
printf("%d ",(int)*p++);
}
#else
void print(DataType* p,int n) { }
#endif
void CSortTest::BeginTest(SortFunction fnSort,TestInfo* pInfo) const
{
// 取数
DataType* pData = new DataType[m_nCountData];
for(int i = 0;i < m_nCountData;i++)
pData[i] = m_pSrcData[i];
// 初始化状态信息
DataType::s_nCountCmp = 0;
DataType::s_nCountDlv = 0;
clock_t start = clock();
// 调用排序函数
(*fnSort)(pData,m_nCountData);
// 填充状态信息
pInfo->nTimeCost = clock() - start;
pInfo->nCountCmp = DataType::s_nCountCmp;
pInfo->nCountDlv = DataType::s_nCountDlv;
// 释放排序数组
delete [] pData;
}
void CSortTest::LoadFrom(const int* pData,size_t nCount)
{
delete m_pSrcData;
m_nCountData = nCount;
m_pSrcData = new DataType[nCount];
for(size_t i = 0;i < nCount;i++)
m_pSrcData[i] = pData[i];
}
bool CSortTest::LoadFrom(char* szFilename)
{
delete m_pSrcData;
m_nCountData = 0;
FILE* pFile = fopen(szFilename,"r");
if(pFile == NULL)
{
m_pSrcData = NULL;
return 0;
}
// 测试数据总量
int temp;
while(fscanf(pFile,"%d",&temp) != EOF)
m_nCountData++;
// 加载到内存
m_pSrcData = new DataType[m_nCountData];
DataType* p = m_pSrcData;
fseek(pFile,0,SEEK_SET);
while(fscanf(pFile,"%d",&temp) != EOF)
*p++ = temp;
return 1;
}
// 自动生成数据函数组
VOID_NAMESPACE_BEGIN
#define DST ORDERED_DENSITY
#define DGR ORDERED_DEGREE
DataType* LoadRand(size_t nCount)
{
srand((unsigned)time(NULL));
DataType* pData = new DataType[nCount];
for(size_t i = 0;i < nCount;i++)
pData[i] = rand();
return pData;
}
DataType* LoadMostAsc(size_t nCount)
{
srand((unsigned)time(NULL));
DataType* pData = new DataType[nCount];
// 生成升序序列
pData[0] = rand() % DST;
size_t i = 1;
for(;i < nCount;i++)
pData[i] = pData[i - 1] + rand() % DST;
// 部分随机打乱
size_t nBad = nCount - (DGR/100)*nCount;
for(i = 0;i < nBad;i++)
{
int j = rand() % nCount;
if(rand()%2 && pData[j] != DST)
pData[j] = rand() % (pData[j] - DST);
else
pData[j] = pData[j] + DST + rand() % pData[nCount - 1];
}
return pData;
}
DataType* LoadMostDsc(size_t nCount)
{
srand((unsigned)time(NULL));
DataType* pData = new DataType[nCount];
// 生成升序序列
pData[nCount - 1] = rand() % DST;
size_t i = nCount - 1;
for(;i > 0;i--)
pData[i - 1] = pData[i] + rand() % DST;
// 部分随机打乱
size_t nBad = nCount - (DGR/100)*nCount;
for(i = 0;i < nBad;i++)
{
int j = rand() % nCount;
if(!(rand()%2) && pData[j] != DST)
pData[j] = rand() % (pData[j] - DST);
else
pData[j] = pData[j] + DST + rand() % pData[0];
}
return pData;
}
VOID_NAMESPACE_END
bool CSortTest::LoadAuto(size_t nCount,size_t nMethod)
{
delete [] m_pSrcData;
m_nCountData = nCount;
switch(nMethod)
{
case LA_RAND:
m_pSrcData = LoadRand(nCount);
break;
case LA_MOST_ASC:
m_pSrcData = LoadMostAsc(nCount);
break;
case LA_MOST_DSC:
m_pSrcData = LoadMostDsc(nCount);
break;
default:
m_pSrcData = NULL;
return 0;
}
return 1;
}
