xset.h

BCB的学习资料

{
    return m_Data[Index];
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]XSet
[Title]XSet的构造函数
////////////////////////////////////////////////////////////////////////////////
[Param]
    <int default = 0> iPrepareLength 预先准备的元素个数
[Description]
    缺省构造函数
[Version]2.1
[Author]Rex Winter
[Date]2005-6-22
////////////////////////////////////////////////////////////////////////////////
[Description]
    缺省构造函数
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T>::XSet(int iPrepareLength)
    :m_Data(0,iPrepareLength)
{}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]XSet()
[Title]XSet的构造函数
////////////////////////////////////////////////////////////////////////////////
<Param>
    <T> vMin 开始元素值的最小值
    <T> vMax 开始元素值的最大值
    <int default = 0> iPrepareLength 预先准备的元素个数
[Description]
    修改了其构造方法，避免产生没有代码[如果T为类为结构体的话]
[Version]2.2
[Author]Rex Winter
[Date]2005-6-22
////////////////////////////////////////////////////////////////////////////////
<Param>
    <T> vMin 开始元素值的最小值
    <T> vMax 开始元素值的最大值
[Description]
    修改了其构造方法，避免产生没有代码[如果T为类为结构体的话]
[Version]2.1
[Author]Rex Winter
[Date]2005-3-26
////////////////////////////////////////////////////////////////////////////////
<Param>
    <T> vMin 开始元素值的最小值
    <T> vMax 开始元素值的最大值
[Description]
    XSet的构造函数，并指定元素初始化的范围
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T>::XSet(const T & vMin,const T & vMax,int iPrepareLength)
    :m_Data(0,iPrepareLength)
{
    if( vMin > vMax )
    {
        for( T i = vMax; i<=vMin; ++i )
        {
            m_Data.Append(i);
        }
    }
    else
    {
        for( T i = vMin; i<=vMax; ++i )
        {
           m_Data.Append(i);
        }
    }
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]XSet()
[Title]XSet的构造函数
////////////////////////////////////////////////////////////////////////////////
<Param>
    <const XSet<T> &> rhs 被指定初始化的集合
[Description]
    XSet的构造函数，并指定的初始化目标集合
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T>::XSet(const XSet<T> & rhs)
    :m_Data( rhs.m_Data )
{
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]Empty()
[Title]判断集合是否为空
////////////////////////////////////////////////////////////////////////////////
[Return]
    <bool> 如果集合中没有元素，则返回true,否则返回假
[Description]
    判断集合是否为空，如果集合中没有元素，则返回真，否则返回假
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
bool XSet<T>::Empty() const
{
    if( m_Data.GetLength() == 0 ) return true;
    else return false;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator =
[Title]集合的赋值操作
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 被赋值的源集合
[Return]
    <XSet<T> &> 返回当前集合的引用
[Description]
    集合的赋值，使录集合的与源集合完全一样
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T> & XSet<T>::operator = (const XSet<T> & rhs)
{
    m_Data = rhs.m_Data;
    return *this;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator -
[Title]集合的差集操作
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 差集集合
[Return]
    <XSet<T>> 返回差集集合
[Description]
    集合的差集操作，这个操作，会返回一个新的集合，这个集合中的元素，分是属于两个集合
    的元素，但又不是两个集合的共有元素
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T> XSet<T>::operator-(const XSet<T> & rhs) const
{
    XSet<T> ret;
    if( this != &rhs )
    {
        const T * Data = m_Data.Data();
        int iLength = m_Data.GetLength();
        for(int i=0; i<iLength; i++,Data++)
        {
            if( !rhs.Contains( *Data ) ) ret.Add( *Data );
        }
        Data = rhs.m_Data.Data();
        iLength = rhs.GetLength();
        for(int i=0; i<iLength; i++,Data++)
        {
            if( !Contains( *Data ) ) ret.Add( *Data );
        }
    }
    return ret;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator *
[Title]集合的交集操作
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 交集集合
[Return]
    <XSet<T>> 返回交集集合
[Description]
    集合的交集操作，这个操作，会返回一个新的集合，这个集合中的元素，是两个集合的共有
    的元素
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T> XSet<T>::operator*(const XSet<T> & rhs) const
{
    XSet<T> ret;
    if( this != & rhs )
    {
        const T * Data = m_Data.Data();
        int iLength = m_Data.GetLength();
        for(int i=0; i<iLength; i++,Data++)
        {
            if( rhs.Contains( *Data ) ) ret.Add ( *Data );
        }
    }
    else ret = rhs;
    return ret;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator +
[Title]集合的并集操作
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 并集集合
[Return]
    <XSet<T>> 返回并集集合
[Description]
    集合的并集操作，这个操作，会返回一个新的集合，这个集合包含了两个集合的所有元素
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T> XSet<T>::operator+(const XSet<T> & rhs) const
{
    XSet<T> ret = rhs;
    ret.Add(*this);
    return ret;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator ==
[Title]比较两个集合是否相等
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 比较的集合
[Return]
    <bool> 如果两个集合中，所有元素都相同，则返回真,否则返回假
[Description]
    比较两个集合是否相等
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
bool XSet<T>::operator == (const XSet<T> & rhs) const
{
    if( this == &rhs ) return true;
    int iLength = m_Data.GetLength();
    if( rhs.m_Data.GetLength() != iLength ) return false;

    for(int i=0;i<iLength;i++)
    {
        if( m_Data[i] != rhs[i] ) return false;
    }
    return true;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator !=
[Title]比较两个集合是否不相等
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 比较的集合
[Return]
    <bool> 如果两个集合中，所有元素都相同，则返回假,否则返回true
[Description]
    比较两个集合是否不相等
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
bool XSet<T>::operator != (const XSet<T> & rhs) const
{
    if( this == &rhs ) return false;
    int iLength = m_Data.GetLength();
    if( rhs.m_Data.GetLength() != iLength ) return true;
    if( iLength == 0 ) return false; //如果两个都空集
    for(int i=0;i<iLength;i++)
    {
        if( m_Data[i] == rhs[i] ) return false;
    }
    return true;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator -=
[Title]集合的差集运算
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 差集集息
[Return]
    <XSet<T> &> 返回当前集合的引用
[Description]
    两个集合做差集远算后，并将结果放到当前集合中
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T> & XSet<T>::operator-=(const XSet<T> & rhs)
{
    if( this != &rhs )
    {
        if( !rhs.Empty() )
        {
            if( Empty() )
            {
                return *this = rhs;
            }
            else
            {
                XSet<T> tmp = rhs;
                tmp *= *this;      
                *this += rhs;
                Delete(tmp);
            }
        }
    } else Clear();
    return *this;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator -=
[Title]集合的并集运算
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 并集集息
[Return]
    <XSet<T> &> 返回当前集合的引用
[Description]
    两个集合做并集远算后，并将结果放到当前集合中
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T> & XSet<T>::operator+=(const XSet<T> & rhs)
{
    Add(rhs);
    return *this;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator *=
[Title]集合的交集运算
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XSet<T> &>rhs 交集集息
[Return]
    <XSet<T> &> 返回当前集合的引用
[Description]
    两个集合做交集远算后，并将结果放到当前集合中
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T> & XSet<T>::operator*=(const XSet<T> & rhs)
{
    if( this != &rhs )
    {
        if( !rhs.Empty() )
        {
            if( !Empty() )
            {
                int iLength = m_Data.GetLength();
                const T * Data = m_Data.Data() + iLength;
                for(int i=iLength-1; i>=0; i--)
                {
                    Data--;
                    if( !rhs.Contains(*Data) ) m_Data.Delete(i);
                }
            }
        }
    }
    return *this;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]SubSet
[Title]取集合的子集
////////////////////////////////////////////////////////////////////////////////
[Param]
    <T>MinData 集合的最小值
    <T>MaxData 集合的最大值
[Return]
    <XSet<T>> 返回子集集合
[Description]
    从当前集合中，取出子集中的元素，并做为一个新的集合返回
[Version]2.0
[Author]Rex Winter
[Date]2004-12-9
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XSet<T> XSet<T>::SubSet(const T & MinData,const T & MaxData) const
{
    const T *max=&MaxData;
    const T *min=&MinData;
    if( MinData > MaxData )
    {
        max = min;
        min = &MaxData;
    }
    XSet<T> ret;
    const T * data = m_Data.Data();
    int iLength = m_Data.GetLength();
    for(int i = 0; i<iLength;i++)
    {
        if( (*data >= *min) && (*data <= *max) ) ret.m_Data.Append(*data);
        data++;
    }
    return ret;
}
//----------------------------------------------------------------------------


};
#endif