C++源码分享（二）：区间泛型类

区间泛型类支持区间(通用数据类型)的交、并、减欧拉操作（目前版本不提供补）,使用方式参见测试函数

//**********************************************************************

// Copyright (c) 2010

// 迪斯特软件开发小组.

// 文件: Range.hpp

// 内容:

// 历史:

// 序号 修改时间 修改人 修改内容

// 1 2010-7-21 hlq 首次生成

//*********************************************************************

//声明本头文件宏

#ifndef _RANGE_HPP

#define _RANGE_HPP

//包含头文件

#include <algorithm>

#include <iterator>

#include <set>

#include <cassert>

#include "FloatCompare.hpp"

//禁用Window定义的宏min、max

#ifdef min

#undef min

#endif

#ifdef max

#undef max

#endif

//类前向声明

template <typename T> class CRangeT;

template <typename T> class CRangeSetT;

//**********************************************************************

// 类名: CRangeT

// 目的: 区间类

//*********************************************************************

template <typename T>

class CRangeT

{

////类型声明

public:

typedef CRangeT<T> my_type;

typedef T value_type;

typedef std::pair<my_type,my_type> range_pair_type;

////业务处理

public:

//两个区间是否相连

bool IsAdjacent(const my_type& rhs) const { return Equal(m_maxValue,rhs.m_minValue) || Equal(m_minValue,rhs.m_maxValue);}

//两个区间是否相交

bool IsIntersect(const my_type& rhs) const {return Great(m_maxValue,rhs.m_minValue) && Less(m_minValue,rhs.m_maxValue);}

//是否包含目标对象

bool IsContain(const my_type& rhs) const {return GreatEqual(rhs.m_minValue,m_minValue) && LessEqual(rhs.m_maxValue,m_maxValue);}

//得到区间交

const my_type GetIntersect(const my_type& rhs) const;

//得到区间并集

const range_pair_type GetUnion(const my_type& rhs) const;

//得到区间差差集

const range_pair_type GetDifference(const my_type& rhs) const;

//得到区间异或集

const range_pair_type GetExclusiveOr(const my_type& rhs) const;

////操作符重载

public:

//等于操作符重载

bool operator==(const my_type& rhs) const {return Equal(m_minValue,rhs.m_minValue) && Equal(m_maxValue,rhs.m_maxValue);}

//不等于操作符重载

bool operator!=(const my_type& rhs) const {return Unequal(m_minValue,rhs.m_minValue) || Unequal(m_maxValue,rhs.m_maxValue);}

//小于操作符重载

bool operator <(const my_type& rhs) const {return Less(m_minValue,rhs.m_minValue);}

//小于等于操作符重载

bool operator <=(const my_type& rhs) const {return LessEqaul(m_minValue,rhs.m_minValue);}

//大于操作符重载

bool operator >(const my_type& rhs) const {return Great(m_minValue,rhs.m_minValue);}

//大于等于操作符重载

bool operator >=(const my_type& rhs) const {return GreatEqaul(m_minValue,rhs.m_minValue);}

////基本查询

public:

//得到最小值

const value_type& GetMinValue(void) const {return m_minValue;}

//得到最大值

const value_type& GetMaxValue(void) const {return m_maxValue;}

//得到区间值

value_type GetRange(void) const {return m_maxValue - m_minValue;}

//是否为空

bool IsEmpty(void) const {return Equal(GetRange(),0);}

////命令

public:

//设置区间

void SetValues(const value_type aMinValue, const value_type aMaxValue) {m_minValue = aMinValue;m_maxValue = aMaxValue;VerifyConstraint();}

////构造、析构函数

public:

//默认构造函数

CRangeT(const value_type aMinValue = 0, const value_type aMaxValue = 0) : m_minValue(aMinValue),m_maxValue(aMaxValue){VerifyConstraint();}

//零区间

static const my_type& Zero(void) { static my_type s_aZeroInstance(0,0);return s_aZeroInstance;}

////执行函数

private:

//确保区间约束

void VerifyConstraint(void) { if(m_minValue > m_maxValue) std::swap(m_minValue,m_maxValue);}

////数据成员

private:

value_type m_minValue;

value_type m_maxValue;

};

//**********************************************************************

// 函数: GetIntersect

// 功能: 得到区间相交

//*********************************************************************

template <typename T>

inline const CRangeT<T> CRangeT<T>::GetIntersect(const my_type& rhs) const

{

//检查是否相交

if(!IsIntersect(rhs))

return Zero();

//计算相交区间

value_type dMinValue = std::max(m_minValue,rhs.m_minValue);

value_type dMaxValue = std::min(m_maxValue,rhs.m_maxValue);

return my_type(dMinValue,dMaxValue);

}

//**********************************************************************

// 函数: GetUnion

// 功能: 得到并集

//*********************************************************************

template <typename T>

inline const typename CRangeT<T>::range_pair_type CRangeT<T>::GetUnion(const my_type& rhs) const

{

if(IsIntersect(rhs) || IsAdjacent(rhs))

return range_pair_type(my_type(std::min(m_minValue,rhs.m_minValue),std::max(m_maxValue,rhs.m_maxValue)),Zero());

else

return (*this < rhs) ? range_pair_type(*this,rhs) : range_pair_type(rhs,*this);

}

//**********************************************************************

// 函数: GetDifference

// 功能: 区间差

//*********************************************************************

template <typename T>

inline const typename CRangeT<T>::range_pair_type CRangeT<T>::GetDifference(const my_type& rhs) const

{

//检查是否相交

if(!IsIntersect(rhs))

return range_pair_type(*this,Zero());

else if(rhs.IsContain(*this))

return range_pair_type(Zero(),Zero());

//得到相交区间

my_type aTemp = GetIntersect(rhs);

if(Equal(aTemp.m_minValue,m_minValue))

return range_pair_type(my_type(aTemp.m_maxValue,m_maxValue),Zero());

else if(Equal(aTemp.m_maxValue,m_maxValue))

return range_pair_type(my_type(m_minValue,aTemp.m_minValue),Zero());

else

return range_pair_type(my_type(m_minValue,aTemp.m_minValue),my_type(aTemp.m_maxValue,m_maxValue));

}

//**********************************************************************

// 函数: GetExclusiveOr

// 功能: 得到区间异或集

//*********************************************************************

template <typename T>

inline const typename CRangeT<T>::range_pair_type CRangeT<T>::GetExclusiveOr(const my_type& rhs) const

{

//检查是否邻接或相交

if(IsAdjacent(rhs))

return range_pair_type(my_type(std::min(m_minValue,rhs.m_minValue),std::max(m_maxValue,rhs.m_maxValue)),Zero());

else if(!IsIntersect(rhs))

return (*this < rhs) ? range_pair_type(*this,rhs) : range_pair_type(rhs,*this);

//得到差集

range_pair_type aResult = GetDifference(rhs);

if(aResult.first.IsEmpty() || aResult.second.IsEmpty())

{

range_pair_type aTempPair = rhs.GetDifference(*this);

if(!aTempPair.first.IsEmpty())

{

if(aResult.first.IsEmpty())

aResult.first = aTempPair.first;

else

aResult.second = aTempPair.first;

}

if(!aTempPair.second.IsEmpty())

{

if(aResult.first.IsEmpty())

aResult.first = aTempPair.second;

else

aResult.second = aTempPair.second;

}

}

//返回

if((!aResult.first.IsEmpty()) && (!aResult.second.IsEmpty()) && (aResult.first > aResult.second))

std::swap(aResult.first,aResult.second);

return aResult;

}

//**********************************************************************

// 类名: CRangeSetT

// 目的: 区间集合类

//*********************************************************************

template <typename T>

class CRangeSetT

{

////类型声明

public:

typedef CRangeSetT<T> my_type;

typedef std::set<CRangeT<T> > container_type;

typedef typename container_type::value_type range_type;

typedef typename container_type::iterator iterator;

typedef typename container_type::const_iterator const_iterator;

typedef typename container_type::size_type size_type;

typedef size_type index_type;

typedef typename range_type::value_type value_type;

typedef typename range_type::range_pair_type range_pair_type;

////业务处理

public:

//区间并

void Union(const range_type& aRange);

//区间并

void Union(const value_type dMinValue,const value_type dMaxValue) { Union(range_type(dMinValue,dMaxValue));}

//区间差

void Difference(const range_type& aRange);

//区间差

void Difference(const value_type dMinValue,const value_type dMaxValue) { Difference(range_type(dMinValue,dMaxValue));}

//区间合并

const my_type GetUnion(const my_type& aRangeSet) const;

//区间差

const my_type GetDifference(const my_type& aRangeSet) const;

////操作符重载

public:

//等于操作符重载

bool operator==(const my_type& rhs) const {return m_aRanges == rhs.m_aRanges;}

//不等于操作符重载

bool operator!=(const my_type& rhs) const {return m_aRanges != rhs.m_aRanges;}

////基本查询

public:

//得到集合数量

size_type GetCount(void) const {return m_aRanges.size();}

//得到指定区间

const range_type& Get(size_type nIndex) const { const_iterator p = begin(); std::advance(p,nIndex);return *p;}

////命令

public:

//清除

void Clear(void) { m_aRanges.clear();}

////迭代器实现

public:

iterator begin(void) { return m_aRanges.begin();}

const_iterator begin(void) const { return m_aRanges.begin();}

iterator end(void) { return m_aRanges.end();}

const_iterator end(void) const { return m_aRanges.end();}

////执行函数

private:

//合并相邻区间

void CombineAdjacentRanges(void);

////数据成员

private:

container_type m_aRanges; //区间集合

};

//**********************************************************************

// 函数: CombineAdjacentRange

// 功能: 合并相邻区间

//*********************************************************************

template <typename T>

inline void CRangeSetT<T>::CombineAdjacentRanges(void)

{

bool bFound = true;

do

{

bFound = false;

iterator pEnd = end();

iterator p = begin();

iterator pNext = p;

for(++pNext; (p != pEnd) && (pNext != pEnd);++p,++pNext)

{

if(p->IsAdjacent(*pNext))

{

*p = p->GetUnion(*pNext).first;

m_aRanges.erase(pNext);

bFound = true;

break;

}

}

}while(bFound);

}

//**********************************************************************

// 函数: Union

// 功能: 区间并

//*********************************************************************

template <typename T>

inline void CRangeSetT<T>::Union(const range_type& aRange)

{

//假如不存在元素,直接添加

if(m_aRanges.empty())

{

m_aRanges.insert(aRange);

return;

}

//假如某个区间包含当前区间,忽略返回

iterator pEnd = end();

for(iterator p = begin(); p != pEnd;++p)

{

if(p->IsContain(aRange))

return;

}

//剔除本区间完整包含的已有区间

bool bFound = true;

do

{

bFound = false;

iterator pEnd = end();

for(iterator p = begin(); p != pEnd;++p)

{

if(aRange.IsContain(*p))

{

m_aRanges.erase(p);

bFound = true;

break;

}

}

}while(bFound);

//调整与本区间相交的已有区间

pEnd = end();

for(iterator p = begin(); p != pEnd;++p)

{

if(p->IsIntersect(aRange))

{

range_type aTemp = p->GetIntersect(aRange);

*p = p->GetDifference(aTemp).first;

}

}

//添加本区间

m_aRanges.insert(aRange);

//合并相邻区间

CombineAdjacentRanges();

}

//**********************************************************************

// 函数: Difference

// 功能: 区间差

//*********************************************************************

template <typename T>

inline void CRangeSetT<T>::Difference(const range_type& aRange)

{

//剔除当前区间包含的子区间

bool bFound = true;

do

{

bFound = false;

iterator pEnd = end();

for(iterator p = begin(); p != pEnd;++p)

{

if(aRange.IsContain(*p))

{

m_aRanges.erase(p);

bFound = true;

break;

}

}

}while(bFound);

//处理子区间完全包含当前区间的情况

iterator pEnd = end();

for(iterator p = begin(); p != pEnd;++p)

{

if(p->IsContain(aRange))

{

range_pair_type aPair = p->GetDifference(aRange);

m_aRanges.erase(p);

if(!aPair.first.IsEmpty())

m_aRanges.insert(aPair.first);

if(!aPair.second.IsEmpty())

m_aRanges.insert(aPair.second);

return;

}

}

//调整处理交叉区间

pEnd = end();

for(iterator p = begin(); p != pEnd;++p)

{

if(p->IsIntersect(aRange))

{

range_pair_type aPair = p->GetDifference(aRange);

*p = aPair.first;

}

}

}

//**********************************************************************

// 函数: GetUnion

// 功能: 区间合并

//*********************************************************************

template <typename T>

inline const CRangeSetT<T> CRangeSetT<T>::GetUnion(const my_type& aRangeSet) const

{

my_type aTemp(aRangeSet);

const_iterator pEnd = end();

for(const_iterator p = begin(); p != pEnd;++p)

aTemp.Union(*p);

return aTemp;

}

//**********************************************************************

// 函数: GetDifference

// 功能: 区间差

//*********************************************************************

template <typename T>

inline const CRangeSetT<T> CRangeSetT<T>::GetDifference(const my_type& aRangeSet) const

{

my_type aTemp(aRangeSet);

const_iterator pEnd = end();

for(const_iterator p = begin(); p != pEnd;++p)

aTemp.Difference(*p);

return aTemp;

}

//**********************************************************************

// 函数: CRangeT_Test

// 功能: 区间测试

//*********************************************************************

template<typename T>

inline void CRangeT_Test(void)

{

//类型声明

typedef CRangeT<T> range_type;

typedef typename range_type::value_type value_type;

typedef typename range_type::range_pair_type range_pair_type;

//声明变量

value_type dMinValue = 100;

value_type dMaxValue = 200;

value_type dValueLess1 = 60;

value_type dValueLess2 = 80;

value_type dValue1 = 120;

value_type dValue2 = 140;

value_type dValue3 = 160;

value_type dValue4 = 180;

value_type dValueGreat1 = 220;

value_type dValueGreat2 = 240;

range_type aRange(dMinValue,dMaxValue);

//测试用例1: 交测试

assert(aRange.GetIntersect(range_type(dValueLess1,dValueLess2)) == range_type::Zero());

assert(aRange.GetIntersect(range_type(dValueLess1,dMinValue)) == range_type::Zero());

assert(aRange.GetIntersect(range_type(dValueLess1,dValue1)) == range_type(dMinValue,dValue1));

assert(aRange.GetIntersect(range_type(dValueLess1,dMaxValue)) == range_type(dMinValue,dMaxValue));

assert(aRange.GetIntersect(range_type(dValueLess1,dValueGreat1)) == range_type(dMinValue,dMaxValue));

assert(aRange.GetIntersect(range_type(dMinValue,dMinValue)) == range_type::Zero());

assert(aRange.GetIntersect(range_type(dMinValue,dValue1)) == range_type(dMinValue,dValue1));

assert(aRange.GetIntersect(range_type(dMinValue,dMaxValue)) == range_type(dMinValue,dMaxValue));

assert(aRange.GetIntersect(range_type(dMinValue,dValueGreat1)) == range_type(dMinValue,dMaxValue));

assert(aRange.GetIntersect(range_type(dValue1,dValue2)) == range_type(dValue1,dValue2));

assert(aRange.GetIntersect(range_type(dValue1,dMaxValue)) == range_type(dValue1,dMaxValue));

assert(aRange.GetIntersect(range_type(dValue1,dValueGreat1)) == range_type(dValue1,dMaxValue));

assert(aRange.GetIntersect(range_type(dMaxValue,dValueGreat1)) == range_type::Zero());

assert(aRange.GetIntersect(range_type(dValueGreat1,dValueGreat2)) == range_type::Zero());

//测试用例2: 并测试

assert(aRange.GetUnion(range_type(dValueLess1,dValueLess2)) == std::make_pair(range_type(dValueLess1,dValueLess2),range_type(dMinValue,dMaxValue)));

assert(aRange.GetUnion(range_type(dValueLess1,dMinValue)) == std::make_pair(range_type(dValueLess1,dMaxValue),range_type::Zero()));

assert(aRange.GetUnion(range_type(dValueLess1,dValue1)) == std::make_pair(range_type(dValueLess1,dMaxValue),range_type::Zero()));

assert(aRange.GetUnion(range_type(dValueLess1,dMaxValue)) == std::make_pair(range_type(dValueLess1,dMaxValue),range_type::Zero()));

assert(aRange.GetUnion(range_type(dValueLess1,dValueGreat1)) == std::make_pair(range_type(dValueLess1,dValueGreat1),range_type::Zero()));

assert(aRange.GetUnion(range_type(dMinValue,dMinValue)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetUnion(range_type(dMinValue,dValue1)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetUnion(range_type(dMinValue,dMaxValue)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetUnion(range_type(dMinValue,dValueGreat1)) == std::make_pair(range_type(dMinValue,dValueGreat1),range_type::Zero()));

assert(aRange.GetUnion(range_type(dValue1,dValue2)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetUnion(range_type(dValue1,dMaxValue)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetUnion(range_type(dValue1,dValueGreat1)) == std::make_pair(range_type(dMinValue,dValueGreat1),range_type::Zero()));

assert(aRange.GetUnion(range_type(dMaxValue,dValueGreat1)) == std::make_pair(range_type(dMinValue,dValueGreat1),range_type::Zero()));

assert(aRange.GetUnion(range_type(dValueGreat1,dValueGreat2)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type(dValueGreat1,dValueGreat2)));

//测试用例3: 差测试

assert(aRange.GetDifference(range_type(dValueLess1,dValueLess2)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetDifference(range_type(dValueLess1,dMinValue)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetDifference(range_type(dValueLess1,dValue1)) == std::make_pair(range_type(dValue1,dMaxValue),range_type::Zero()));

assert(aRange.GetDifference(range_type(dValueLess1,dMaxValue)) == std::make_pair(range_type::Zero(),range_type::Zero()));

assert(aRange.GetDifference(range_type(dValueLess1,dValueGreat1)) == std::make_pair(range_type::Zero(),range_type::Zero()));

assert(aRange.GetDifference(range_type(dMinValue,dMinValue)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetDifference(range_type(dMinValue,dValue1)) == std::make_pair(range_type(dValue1,dMaxValue),range_type::Zero()));

assert(aRange.GetDifference(range_type(dMinValue,dMaxValue)) == std::make_pair(range_type::Zero(),range_type::Zero()));

assert(aRange.GetDifference(range_type(dMinValue,dValueGreat1)) == std::make_pair(range_type::Zero(),range_type::Zero()));

assert(aRange.GetDifference(range_type(dValue1,dValue2)) == std::make_pair(range_type(dMinValue,dValue1),range_type(dValue2,dMaxValue)));

assert(aRange.GetDifference(range_type(dValue1,dMaxValue)) == std::make_pair(range_type(dMinValue,dValue1),range_type::Zero()));

assert(aRange.GetDifference(range_type(dValue1,dValueGreat1)) == std::make_pair(range_type(dMinValue,dValue1),range_type::Zero()));

assert(aRange.GetDifference(range_type(dMaxValue,dValueGreat1)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetDifference(range_type(dValueGreat1,dValueGreat2)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

//测试用例4: 异或

assert(aRange.GetExclusiveOr(range_type(dValueLess1,dValueLess2)) == std::make_pair(range_type(dValueLess1,dValueLess2),range_type(dMinValue,dMaxValue)));

assert(aRange.GetExclusiveOr(range_type(dValueLess1,dMinValue)) == std::make_pair(range_type(dValueLess1,dMaxValue),range_type::Zero()));

assert(aRange.GetExclusiveOr(range_type(dValueLess1,dValue1)) == std::make_pair(range_type(dValueLess1,dMinValue),range_type(dValue1,dMaxValue)));

assert(aRange.GetExclusiveOr(range_type(dValueLess1,dMaxValue)) == std::make_pair(range_type(dValueLess1,dMinValue),range_type::Zero()));

assert(aRange.GetExclusiveOr(range_type(dValueLess1,dValueGreat1)) == std::make_pair(range_type(dValueLess1,dMinValue),range_type(dMaxValue,dValueGreat1)));

assert(aRange.GetExclusiveOr(range_type(dMinValue,dMinValue)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type::Zero()));

assert(aRange.GetExclusiveOr(range_type(dMinValue,dValue1)) == std::make_pair(range_type(dValue1,dMaxValue),range_type::Zero()));

assert(aRange.GetExclusiveOr(range_type(dMinValue,dMaxValue)) == std::make_pair(range_type::Zero(),range_type::Zero()));

assert(aRange.GetExclusiveOr(range_type(dMinValue,dValueGreat1)) == std::make_pair(range_type(dMaxValue,dValueGreat1),range_type::Zero()));

assert(aRange.GetExclusiveOr(range_type(dValue1,dValue2)) == std::make_pair(range_type(dMinValue,dValue1),range_type(dValue2,dMaxValue)));

assert(aRange.GetExclusiveOr(range_type(dValue1,dMaxValue)) == std::make_pair(range_type(dMinValue,dValue1),range_type::Zero()));

assert(aRange.GetExclusiveOr(range_type(dValue1,dValueGreat1)) == std::make_pair(range_type(dMinValue,dValue1),range_type(dMaxValue,dValueGreat1)));

assert(aRange.GetExclusiveOr(range_type(dMaxValue,dValueGreat1)) == std::make_pair(range_type(dMinValue,dValueGreat1),range_type::Zero()));

assert(aRange.GetExclusiveOr(range_type(dValueGreat1,dValueGreat2)) == std::make_pair(range_type(dMinValue,dMaxValue),range_type(dValueGreat1,dValueGreat2)));

}

//**********************************************************************

// 函数: CRangeSetT_Test

// 功能: 区间集合测试

//*********************************************************************

template<typename T>

inline void CRangeSetT_Test(void)

{

//执行区间测试

CRangeT_Test<T>();

//类型声明

typedef CRangeSetT<T> range_set_type;

typedef typename range_set_type::range_type range_type;

typedef typename range_type::value_type value_type;

//声明变量

value_type dMinValue = 100;

value_type dMaxValue = 200;

value_type dValueLess1 = 60;

value_type dValueLess2 = 80;

value_type dValue1 = 120;

value_type dValue2 = 140;

value_type dValue3 = 160;

value_type dValue4 = 180;

value_type dValueGreat1 = 220;

value_type dValueGreat2 = 240;

range_set_type aDashedSet,aSolidSet,aFullSet;

aDashedSet.Union(range_type(dMinValue,dMaxValue));

aFullSet.Union(range_type(dMinValue,dMaxValue));

//测试用例1: 区间集并

aSolidSet.Union(range_type(dValue1,dValue2));

aSolidSet.Union(range_type(dValue3,dValue4));

aSolidSet.Union(range_type(dValueGreat1,dValueGreat2));

assert(aSolidSet.GetCount() == 3);

assert(aSolidSet.Get(0) == range_type(dValue1,dValue2));

assert(aSolidSet.Get(1) == range_type(dValue3,dValue4));

assert(aSolidSet.Get(2) == range_type(dValueGreat1,dValueGreat2));

aSolidSet.Union(range_type((dValue1 + dValue2) / 2,(dValue2 + dValue3) / 2));

assert(aSolidSet.GetCount() == 3);

assert(aSolidSet.Get(0) == range_type(dValue1,(dValue2 + dValue3) / 2));

assert(aSolidSet.Get(1) == range_type(dValue3,dValue4));

assert(aSolidSet.Get(2) == range_type(dValueGreat1,dValueGreat2));

aSolidSet.Union(range_type(dValue2,(dValueGreat1 + dValueGreat2) / 2));

assert(aSolidSet.GetCount() == 1);

assert(aSolidSet.Get(0) == range_type(dValue1,dValueGreat2));

//测试用例2: 区间集减

aDashedSet.Difference(range_type(dValue1,dValue2));

assert(aDashedSet.GetCount() == 2);

assert(aDashedSet.Get(0) == range_type(dMinValue,dValue1));

assert(aDashedSet.Get(1) == range_type(dValue2,dMaxValue));

aDashedSet.Difference(range_type(dValue3,dValue4));

assert(aDashedSet.GetCount() == 3);

assert(aDashedSet.Get(0) == range_type(dMinValue,dValue1));

assert(aDashedSet.Get(1) == range_type(dValue2,dValue3));

assert(aDashedSet.Get(2) == range_type(dValue4,dMaxValue));

aDashedSet.Difference(range_type((dMinValue + dValue1) / 2,(dValue4 + dMaxValue) / 2));

assert(aDashedSet.GetCount() == 2);

assert(aDashedSet.Get(0) == range_type(dMinValue,(dMinValue + dValue1) / 2));

assert(aDashedSet.Get(1) == range_type((dValue4 + dMaxValue) / 2,dMaxValue));

//测试用例3: 演示

aDashedSet.Clear();

aDashedSet.Union(range_type(dMinValue,dMaxValue));

aSolidSet.Clear();

assert(aDashedSet.GetUnion(aSolidSet) == aFullSet);

aDashedSet.Difference(range_type(dValue1,dValue2));

aSolidSet.Union(range_type(dValue1,dValue2));

assert(aDashedSet.GetUnion(aSolidSet) == aFullSet);

aDashedSet.Difference(range_type(dValue3,dValue4));

aSolidSet.Union(range_type(dValue3,dValue4));

assert(aDashedSet.GetUnion(aSolidSet) == aFullSet);

aDashedSet.Difference(range_type(dValue2,dValue3));

aSolidSet.Union(range_type(dValue2,dValue3));

assert(aDashedSet.GetUnion(aSolidSet) == aFullSet);

assert(aDashedSet.GetCount() == 2);

assert(aDashedSet.Get(0) == range_type(dMinValue,dValue1));

assert(aDashedSet.Get(1) == range_type(dValue4,dMaxValue));

assert(aSolidSet.GetCount() == 1);

assert(aSolidSet.Get(0) == range_type(dValue1,dValue4));

}

#endif //假如未定义_RANGE_HPP宏

胡乐秋

2010/8/3
http://blog.csdn.net/hlqyq