专职C++

不能停止的脚步

  C++博客 :: 首页 :: 联系 :: 聚合  :: 管理
  153 Posts :: 7 Stories :: 135 Comments :: 0 Trackbacks

常用链接

留言簿(13)

我参与的团队

搜索

  •  

最新评论

阅读排行榜

评论排行榜

60天内阅读排行

受不了STL的字符串了,决定自己实现一个。没有什么技术含量,无非就是简单易用。字符串与浮点数之间的转换,还没有实现。还有Unicode与多字节转换还没有实现。当然,这个网上有太多的实现办法,呵呵。这个字符串类分为两部分,一部分是通用函数实现,主要在string_utils名称空间中。
下面是字符串的实现代码。希望能给初学者提供一点学习的参考。
/*
 * xstring.h
 * 字符串类
 * 字符串类未充分测试
 
*/

#ifndef X_STRING_H_
#define X_STRING_H_
#include 
<xconfig.h>
#include 
<xtype.h>
#include 
<xmemory.h>
#include 
<cassert>
#include 
<xutils.h>

#if CONFIG_WINDOWS
    #include 
<windows.h>
#elif CONFIG_LINUX
    #include 
<wchar.h>
#endif


#ifdef CONFIG_BCB
    #include 
<stdio.h>
    #include 
<stdarg.h>
#else
    #include 
<cstdio>
    #include 
<cstdarg>
#endif

#include 
<iostream>

namespace zdh
{
    
using namespace zdh::utils;
    
namespace string_utils
    {
        template
<class T>
        inline 
bool isSpaceTab( T paramCh )
        {
            
return paramCh == ' ' || paramCh == '\t';
        }
        
///检查是否为字母字符
        template<class T>
        inline 
bool isLetter( T paramCh )
        {
            
return (paramCh >= 'a' && paramCh <='z'|| (paramCh >='A' && paramCh <= 'Z');
        }
        
///检查是否为数字字符
        template<class T>
        inline 
bool isDigit( T paramCh)
        {
            
return paramCh >= '0' && paramCh <='9';
        }
        
///检查是否为回车符
        template<class T>
        inline 
bool isEnter(T paramCh) 
        {
            
return paramCh == 13;
        }
        
///检查是否为换行符
        template<class T>
        inline 
bool isNewLine(T paramCh)
        {
            
return paramCh == 10;
        }
        
///检查是否是空格符
        template<class T>
        inline 
bool isSpace(T paramCh)
        {
            
return paramCh == ' ';
        }
        
///检查是否是tab制表符
        template<class T>
        inline 
bool isTab(T paramCh)
        {
            
return paramCh == 9;
        }
        
///检查是否则0字符
        template<class T>
        inline 
bool isZero(T paramCh) 
        {
            
return paramCh == 0;
        }
        
///检查是否则双引号
        template<class T>
        inline 
bool isQuote(T paramCh)
        {
            
return paramCh == '\"';
        }
        
///检查是否则单引号
        template<class T>
        inline 
bool isApos(T paramCh)
        {
            
return paramCh == '\'';
        }
        
///检查是否转定义符
        template<class T>
        inline 
bool isTransport(T paramCh)
        {
            
return paramCh == '\\';
        }
        
///检查是否为左中括号
        template<class T>
        inline 
bool isBracketLeft(T paramCh)
        {
            
return paramCh == '[';
        }
        
///检查是否为右中括号
        template<class T>
        inline 
bool isBracketRight(T paramCh) 
        {
            
return paramCh == ']';
        }
        
///检查是否为#号
        template<class T>
        inline 
bool isNumbersign(T paramCh)
        {
            
return paramCh == '#';
        }
        
///检查是否为分号
        template<class T>
        inline 
bool isSemicolon(T paramCh)
        {
            
return paramCh == ';';
        }
        
///检查是否为=号
        template<class C>
        
bool isEqual(C paramCh)
        {
            
return paramCh == '=';
        }
        
///检查是否为ini的空格
        template<class C>
        
bool isIniSpaceChar(C paramCh)
        {
            
return paramCh == ' ' || paramCh == 9;
        }
        
///检查是否为ini的注释字符
        template<class C>
        
bool isIniComment(C paramCh)
        {
            
return paramCh =='#' || paramCh == ';';
        }
        
///取字符串的长度
        /**
            @param [in] paramValue 要取得长度的字符串指针
            @return 返回取得长度
        
*/
        template
<class T>
        
static XInt Length(const T * paramValue)
        {
            ZDH_ASSERT(paramValue 
!= NULL);
            XInt iRet 
= 0;
            
while*paramValue != 0 )
            {
                paramValue 
++;
                iRet 
++;
            }
            
return iRet;
        }
        
///比较两个字符串
        /**
            @param [in] paramValue1 字符串1
            @param [in] paramValue2 字符串2
            @return 返回字符串比较结果
                - >0 表示paramValue1 > paramValue2
                - 0 表示paramValue1等于paramValue2
                - <0 表示paramValue1 < paramValue2
        
*/
        template
<class T>
        
static XInt Compare(const T * paramValue1, const T * paramValue2)
        {
            ZDH_ASSERT(paramValue1 
!= NULL);
            ZDH_ASSERT(paramValue2 
!= NULL);
            XInt iRet;
            
do 
            {
                iRet 
= *paramValue1 - *paramValue2;
                
if( (iRet == 0&& (*paramValue1 != 0&& (*paramValue2 != 0) )
                {
                    paramValue1 
++;
                    paramValue2 
++;
                }
                
else break;
            } 
while ( !iRet );
            
return iRet;
        }
        
///不分大小写比较两个字符串
        /**
            @param [in] paramValue1 字符串1
            @param [in] paramValue2 字符串2
            @return 返回字符串比较结果
                - >0 表示paramValue1 > paramValue2
                - 0 表示paramValue1等于paramValue2
                - <0 表示paramValue1 < paramValue2
        
*/
        template
<class T>
        
static XInt CompareIC(const T * paramValue1, const T * paramValue2)
        {
            ZDH_ASSERT(paramValue1 
!= NULL);
            ZDH_ASSERT(paramValue2 
!= NULL);
            XInt iRet;
            
do 
            {
                T ch1 
= *paramValue1;
                T ch2 
= *paramValue2;
                
if( ch1 <= 'Z' && ch1 >= 'A' ) ch1 += 32;
                
if( ch2 <= 'Z' && ch2 >= 'A' ) ch2 += 32;
                iRet 
= ch1 - ch2;

                
if( (iRet == 0&& (ch1 != 0&& (ch2 != 0) )
                {
                    paramValue1 
++;
                    paramValue2 
++;
                }
                
else break;
            } 
while ( !iRet );
            
return iRet;
        }
        
///指定比较的字符数的字符串比较
        /**
            @param [in] paramValue1 字符串1
            @param [in] paramValue2 字符串2
            @param [in] paramN        要比较的字符数,要求该值大于等于0
            @return 返回字符串比较结果
                - >0 表示paramValue1 > paramValue2
                - 0 表示paramValue1等于paramValue2
                - <0 表示paramValue1 < paramValue2
        
*/
        template
<class T>
        
static XInt NCompare(const T * paramValue1, const T * paramValue2, XInt paramN)
        {
            ZDH_ASSERT(paramValue1 
!= NULL);
            ZDH_ASSERT(paramValue2 
!= NULL);
            ZDH_ASSERT(paramN 
>= 0);
            
if( paramN == 0 ) return 0;
            XInt iRet;
            
do 
            {
                iRet 
= *paramValue1 - *paramValue2;
                paramN 
--;
                
if( (iRet == 0&& (*paramValue1 != 0&& (*paramValue2 != 0&& paramN > 0)
                {
                    paramValue1 
++;
                    paramValue2 
++;
                }
                
else break;
            } 
while ( 1 );
            
return iRet;
        }
        
///指定比较的字符数的字符串不分大小比较
        /**
            @param [in] paramValue1 字符串1
            @param [in] paramValue2 字符串2
            @param [in] paramN        要比较的字符数,要求该值大于等于0
            @return 返回字符串比较结果
                - >0 表示paramValue1 > paramValue2
                - 0 表示paramValue1等于paramValue2
                - <0 表示paramValue1 < paramValue2
        
*/
        template
<class T>
        
static XInt NCompareIC(const T * paramValue1, const T * paramValue2, XInt paramN)
        {
            ZDH_ASSERT(paramValue1 
!= NULL);
            ZDH_ASSERT(paramValue2 
!= NULL);
            ZDH_ASSERT(paramN 
>= 0);
            
if( paramN == 0 ) return 0;
            XInt iRet;
            
do 
            {
                T ch1 
= *paramValue1;
                T ch2 
= *paramValue2;
                
if( ch1 <= 'Z' && ch1 >= 'A' ) ch1 += 32;
                
if( ch2 <= 'Z' && ch2 >= 'A' ) ch2 += 32;
                iRet 
= ch1 - ch2;
                paramN 
--;
                
if( (iRet == 0&& (*paramValue1 != 0&& (*paramValue2 != 0&& paramN > 0)
                {
                    paramValue1 
++;
                    paramValue2 
++;
                }
                
else break;
            } 
while ( 1 );
            
return iRet;
        }
        
///将32位无符号整数转换为16进制字符串
        /**
            将32位无符号整数转换为16进制字符串
            @param [in] paramValue 被转换的整数
            @param [out] paramBuffer 保存结果的整数,要求大小至少要12字节
            @param [in] paramHexWidth 16进制的宽度,有效宽度1~8
            @param [in] paramHexStyle 十六进制的样式,A表示用大写,a表示用小写
            @param [in] paramHexPrefix 表示是否要加0x前缀,true表示加该前缀,false表示不加该前缀 
            @return 返回转换后的串指针
        
*/
        template
<class T>
        
static T * DWordToHex(XDWord paramValue, T * paramBuffer, XInt paramHexWidth = 1, T paramHexStyle = 'A'bool paramHexPrefix = true)
        {
            ZDH_ASSERT( paramBuffer 
!= NULL );
            T 
* p = paramBuffer;
            
//确定十六进制数据的长度
            XInt iWidth;
            
if( paramHexWidth > 8 ) 
            {
                iWidth 
= 8;
            }
            
else if( paramHexWidth < 1
            {
                iWidth 
= 1;
            }
            
else 
            {
                iWidth 
= paramHexWidth;
            }
            
//确定值
            XDWord dwValue = paramValue;
            
//
            T charArray[8];
            T 
* d = charArray;
            XInt iRealWidth 
= 0;
            
do 
            {
                
*d++ = T(dwValue % 16);
                iRealWidth 
++;
                dwValue 
>>= 4;
                
if( dwValue == 0 )
                {
                    
break;
                }

            } 
while (1);

            
//将不足宽度的地方补0
            for(XInt i = iRealWidth; i < iWidth; i++)    
            {
                
*d++ = 0;
            }
            
//如果有前缀
            if( paramHexPrefix )
            {
                
*p++ = '0';
                
*p++ = 'x';
            }
            T ch;
            
while (d != charArray)
            {
                
--d;
                ch 
= *d;
                
if( ch < 10 ) 
                {
                    
*p++ = ch + '0';
                }
                
else 
                {
                    
* p++ = T(ch - 10 + paramHexStyle);
                }
            }
            
*= 0;
            
//
            return paramBuffer;
        }
        
///将32位有符号整数转换为16进制字符串
        /**
            将32位有符号整数转换为16进制字符串
            @param [in] paramValue 被转换的整数
            @param [out] paramBuffer 保存结果的整数,要求大小至少要12字节
            @param [in] paramHexWidth 16进制的宽度,有效宽度1~8
            @param [in] paramHexStyle 十六进制的样式,A表示用大写,a表示用小写
            @param [in] paramHexPrefix 表示是否要加0x前缀,true表示加该前缀,false表示不加该前缀 
            @return 返回转换后的串指针
        
*/        
        template
<class T>
        inline T 
* IntToHex(XInt paramValue, T * paramBuffer, XInt paramHexWidth = 1, T paramHexStyle = 'A'bool paramHexPrefix = true)
        {
            
return DWordToHex((XDWord)paramValue, paramBuffer, paramHexWidth, paramHexStyle, paramHexPrefix);
        }
        
///将64位无符号整数转换为16进制字符串
        /**
            将64位无符号整数转换为16进制字符串
            @param [in] paramValue 被转换的整数
            @param [out] paramBuffer 保存结果的整数,要求大小至少要12字节
            @param [in] paramHexWidth 16进制的宽度,有效宽度1~16
            @param [in] paramHexStyle 十六进制的样式,A表示用大写,a表示用小写
            @param [in] paramHexPrefix 表示是否要加0x前缀,true表示加该前缀,false表示不加该前缀 
            @return 返回转换后的串指针
        
*/
        template
<class T>
        
static T * DDWordToHex(XDDWord paramValue, T * paramBuffer, XInt paramHexWidth = 1, T paramHexStyle = 'A'bool paramHexPrefix = true)
        {
            ZDH_ASSERT( paramBuffer 
!= NULL );
            T 
* p = paramBuffer;
            
//确定十六进制数据的长度
            XInt iWidth;
            
if( paramHexWidth > 16 ) 
            {
                iWidth 
= 16;
            }
            
else if( paramHexWidth < 1
            {
                iWidth 
= 1;
            }
            
else
            {
                iWidth 
= paramHexWidth;
            }
            
//确定值
            XDDWord ddwValue = paramValue;
            
//
            T charArray[16];
            T 
* d = charArray;
            XInt iRealWidth 
= 0;
            
do 
            {
                
*d++ = T(ddwValue % 16);
                iRealWidth 
++;
                ddwValue 
>>= 4;
                
if( ddwValue == 0 ) 
                {
                    
break;
                }

            } 
while (1);

            
//将不足宽度的地方补0
            for(XInt i = iRealWidth; i < iWidth; i++)    
            {
                
*d++ = 0;
            }
            
//如果有前缀
            if( paramHexPrefix )
            {
                
*p++ = '0';
                
*p++ = 'x';
            }
            T ch;
            
while (d != charArray)
            {
                
--d;
                ch 
= *d;
                
if( ch < 10 ) 
                {
                    
*p++ = ch + '0';
                }
                
else 
                {
                    
* p++ = T(ch - 10 + paramHexStyle);
                }
            }
            
*= 0;
            
//
            return paramBuffer;
        }
        
///将64位有符号整数转换为16进制字符串
        /**
            将64位有符号整数转换为16进制字符串
            @param [in] paramValue 被转换的整数
            @param [out] paramBuffer 保存结果的整数,要求大小至少要12字节
            @param [in] paramHexWidth 16进制的宽度,有效宽度1~16
            @param [in] paramHexStyle 十六进制的样式,A表示用大写,a表示用小写
            @param [in] paramHexPrefix 表示是否要加0x前缀,true表示加该前缀,false表示不加该前缀 
            @return 返回转换后的串指针
        
*/        
        template
<class T>
        inline T 
* LongToHex(XLong paramValue, T * paramBuffer, XInt paramHexWidth = 1, T paramHexStyle = 'A'bool paramHexPrefix = true)
        {
            
return DDWordToHex((XDDWord)paramValue, paramBuffer, paramHexWidth, paramHexStyle, paramHexPrefix);
        }
        
///将32位无符号整数,转换为字符串
        /**
            @param [in] paramValue 将要被转换的无符号整数
            @param [out] paramBuffer 用于保存结果的缓冲区,要求缓冲区至少33字节。
            @param [in] paramRadix 表示转换的进制,默认为10进制,有效进制范围在2到36之间。
            @param [in] paramHexStyle 表示大于9的数字表示方式。默认为'A'
                - a 表示大于10的位数,都是小写字符
                - A 表示大于10的位数,都是大写字符
            @return T * 返回转换后的字符串,实际为paramBuffer的指针。
        
*/        
        template
<class T>
        
static T * DWordToStr(XDWord paramValue, T * paramBuffer, XInt paramRadix = 10, T paramHexStyle = 'A')
        {
            T 
* p = paramBuffer;
            XDWord dwV;

            
if( paramRadix >= 2 && paramRadix <= 36 )
            {
                T _buf[
33];
                T 
*bufp = _buf;
                dwV 
= (XDWord)paramValue;
                
for(;;)
                {
                    
*bufp++ = T(dwV % paramRadix);
                    dwV 
/= paramRadix;
                    
if( dwV == 0 ) break;
                }
                T ch;
                
while (bufp != _buf)
                {
                    
--bufp;
                    ch 
= *bufp;
                    
if( ch < 10 ) *p++ = ch+'0';
                    
else *p++ = T(ch - 10 + paramHexStyle);
                }
            }
            
*= '\0';
            
return paramBuffer;
        }
        
///将32位有符号整数,转换为字符串
        /**
            @param [in] paramValue 将要被转换的整数
            @param [out] paramBuffer 用于保存结果的缓冲区,要求缓冲区至少33字节。
            @param [in] paramRadix 表示转换的进制,默认为10进制,有效进制范围在2到36之间。
            @param [in] paramHexStyle 表示大于9的数字表示方式。默认为'A'
                - a 表示大于10的位数,都是小写字符
                - A 表示大于10的位数,都是大写字符
            @return T * 返回转换后的字符串,实际为paramBuffer的指针。
        
*/
        template
<class T>
        
static T * IntToStr(XInt paramValue, T * paramBuffer, XInt paramRadix = 10, T paramHexStyle = 'A')
        {
            ZDH_ASSERT(paramBuffer 
!= NULL);
            T 
* p = paramBuffer;
            XDWord dwV;

            
if( paramRadix >= 2 && paramRadix <= 36 )
            {
                
//如果整数
                if( paramValue < 0  && paramRadix == 10 )
                {
                    
*p++ = '-';
                    dwV 
= (XDWord)(-paramValue);
                }
                
else 
                {
                    dwV 
= (XDWord)paramValue;
                }

                T _buf[
33];
                T 
*bufp = _buf;
                
for(;;)
                {
                    
*bufp++ = T(dwV % paramRadix);
                    dwV 
/= paramRadix;
                    
if( dwV == 0 ) break;
                }
                T ch;
                
while (bufp != _buf)
                {
                    
--bufp;
                    ch 
= *bufp;
                    
if( ch < 10 ) *p++ = ch+'0';
                    
else *p++ = T(ch - 10 + paramHexStyle);
                }
            }
            
*= '\0';
            
return paramBuffer;
        }
        
//----------------------------------------------------------------------------
        ///将64位有符号整数转换为字符串
        /**
            @param [in] paramValue 被转换的64位整数
            @param [out] paramBuffer 存放转换后的字符串,要求至少要传入65个字符,否则有可能溢出。
            @param [in] paramRadix 转换后的进制,2表示二进制,16表示十六进制,10表示十进制,该值范围是2到36。
            @param [in] paramHexStyle 
                - a 表示大于10的位数,都是小写字符
                - A 表示大于10的位数,都是大写字符
            @return 返回转换的结果。实际上返回的是参数aBuff的值
        
*/
        template
<class T>
        
static T * LongToStr(XLong paramValue,T * paramBuffer,XInt paramRadix = 10,T paramHexStyle = 'A')
        {
            ZDH_ASSERT(paramBuffer
!=NULL);
            T 
* p = paramBuffer;
            XDDWord ddwV;
            
//如果是有效的进制
            if( paramRadix >= 2 && paramRadix <= 36 )
            {
                
if( paramValue < 0 )
                {
                    
*p++ = '-';
                    ddwV 
= XDDWord(-paramValue);
                }
                
else
                {
                    ddwV 
= XDDWord(paramValue);
                }
                T _buf[
65];
                T 
*bufp = _buf;
                
for(;;)
                {
                    
*bufp++ = T(ddwV % paramRadix);
                    ddwV 
/= paramRadix;
                    
if( ddwV == 0 ) 
                    {
                        
break;
                    }
                }
                T ch;
                
while (bufp != _buf)
                {
                    
--bufp;
                    ch 
= *bufp;
                    
if( ch < 10 ) *p++ = ch+'0';
                    
else *p++ = T( ch - 10 + paramHexStyle);
                }
            }
            
*= '\0';
            
return paramBuffer;
        }
        
//----------------------------------------------------------------------------
        ///将64位有符号整数转换为字符串
        /**
            @param [in] paramValue 被转换的64位整数
            @param [out] paramBuffer 存放转换后的字符串,要求至少要传入65个字符,否则有可能溢出。
            @param [in] paramRadix 转换后的进制,2表示二进制,16表示十六进制,10表示十进制,该值范围是2到36。
            @param [in] paramHexStyle 
                - a 表示大于10的位数,都是小写字符
                - A 表示大于10的位数,都是大写字符
            @return 返回转换的结果。实际上返回的是参数aBuff的值
        
*/
        template
<class T>
        
static T * DDWordToStr(XDDWord paramValue,T *paramBuffer,XInt paramRadix = 10,T paramHexStyle = 'A' )
        {
            ZDH_ASSERT(paramBuffer 
!= NULL);
            T 
* p = paramBuffer;
            
if( paramRadix >= 2 && paramRadix <=36 )
            {
                T _buf[
65];
                T 
*bufp = _buf;
                
for(;;)
                {
                    
*bufp++ = T( paramValue % paramRadix);
                    paramValue 
/= paramRadix;
                    
if( paramValue == 0 ) 
                    {
                        
break;
                    }
                }
                T ch;
                
while (bufp != _buf)
                {
                    
--bufp;
                    ch 
= *bufp;
                    
if( ch < 10 ) 
                    {
                        
*p++ = ch+'0';
                    }
                    
else 
                    {
                        
*p++ = XChar(ch-10 + paramHexStyle);
                    }
                }
            }
            
*= '\0';
            
return paramBuffer;
        }
        
///尝试将字符串转换为32位有符号整数模板
        /**
              尝试将字符串转换为32位有符号整数,能够自动识别十进制和十六进制数。
            @param [in] paramNumberString 被转换的数值字符串
             @param [out] paramValue 用于保存转换后的数值
             @return 返回尝试转换的状态
                 - true 表示转换成功
                 - false 表示转换失败,这个时候aValue的值为0
         
*/
        template
<class T>
        
static bool TryStringToInt(const T * paramNumberString, XInt & paramValue)
        {
            
//先初始化为0
            paramValue = 0;
            
if( isNULL(paramNumberString) ) 
            {
                
return true;
            }

            
bool bNegativeFlag = false;    //负数标志
            bool bHexFlag = false;        //十六进制标志

            
const T *= paramNumberString;
            
//跳过空格
            while(*== ' '
            {
                p
++;
            }

            
//检查符号位
            switch(*p) 
            {
            
case 0:
                
return false;
            
case '+':
                
++p;
                
break;
            
case '-':
                bNegativeFlag 
= true;
                
++p;
                
break;
            
case '$'//if $..,x..,X..开头的数字为十六进制
            case 'x':
            
case 'X':
                bHexFlag 
= true;
                
++p;
                
break;
            
case '0'//if 0x..,0X..开头的数字为十六进制
                bHexFlag = ((*(p+1== 'x'|| (*(p+1== 'X')); //(Length(s) > I) and (UpCase(s[I+1]) = 'X');
                if (bHexFlag) 
                {
                    p 
+= 2;
                }
                
break;
            }

            
if (*== 0
            {
                
return false;
            }

            
if (bHexFlag)
            {
                
// INT32的十六进制字符串最多有8个字节
                if (Length(p) > 8
                {
                    
return false;
                }
                XInt iValue 
= 0;
                
while (*!= 0
                {
                    XInt v;
                    T chNumber 
= *p;
                    
if (chNumber >= '0' && chNumber <= '9'//如果是0..9
                    {
                        v 
= chNumber - '0';
                    }
                    
else if (chNumber >= 'a' && chNumber <= 'f'//如果是a..f
                    {
                        v 
= chNumber - 'a' + 10;
                    }
                    
else if (chNumber >= 'A' && chNumber <= 'F'//如果是A..F
                    {
                        v 
= chNumber - 'A' + 10;
                    }
                    
else  //遇到非法数字退出
                    {
                        
return false;
                    }
                    iValue 
*= 16;
                    iValue 
+= v;
                    
++p;
                }
                paramValue 
= iValue;
            }
            
else
            {
                
//  整数最小值是 -2147483648 (0x80000000), 最大值是 2147483647 (0x7FFFFFFF)
                const XInt ABS_MIN_INT_DIV10 = 214748364;
                
const XInt ABS_MIN_INT_MOD10 = 8;
                
const XInt ABS_MAX_INT_DIV10 = 214748364;
                
const XInt ABS_MAX_INT_MOD10 = 7;

                XInt iValue 
= 0;

                
while (*!= 0)
                {
                    T chNumber 
= *p;
                    
if (chNumber < '0' ||chNumber > '9'//如果发现超出有效的字符,则表示转换失败
                    {
                        
return false;
                    }

                    XInt v 
= chNumber - '0';

                    
if (bNegativeFlag) //如果是负数
                    {
                        
if (iValue > ABS_MIN_INT_DIV10) 
                        {
                            
return false;
                        }
                        
if (iValue == ABS_MIN_INT_DIV10)
                        {
                            
if (v > ABS_MIN_INT_MOD10) 
                            {
                                
return false;
                            }

                            
// 因为需要intValue始终是正整数, 其最大值是 2147483647
                            
// 如果此时v=8, 将导致其溢出
                            if (v == ABS_MIN_INT_MOD10)
                            {
                                
// 如果后面没有字符了, 说明这个是最后一个字符, 那么这个数是整型最小值
                                
// 之所以在这里退出, 是为了防止整型最大值溢出
                                if (*(p+1== 0)
                                {
                                    paramValue 
= 0x80000000;
                                    
return true;
                                }
                                
else 
                                {
                                    
return false;
                                }
                            }
                        }
                    }
                    
else //如果是非负数
                    {    
                        
if (iValue > ABS_MAX_INT_DIV10) 
                        {
                            
return false;
                        }
                        
if (iValue == ABS_MAX_INT_DIV10 && v > ABS_MAX_INT_MOD10) 
                        {
                            
return false;
                        }
                    }
                    iValue 
*= 10;
                    iValue 
+= v;
                    
++p;
                }
                
if( bNegativeFlag ) 
                {
                    paramValue 
= -iValue;
                }
                
else 
                {
                    paramValue 
= iValue;
                }
            }
            
return true;
        }


        
//----------------------------------------------------------------------------
        /**
              尝试将字符串转换为32位无符号整数,能够自动识别十进制和十六进制数。
              @param [in] paramNumberString 被转换的数值字符串
              @param [out] paramValue 用于保存转换后的数值
              @return 返回尝试转换的状态
                - true 表示转换成功
                - false 表示转换失败,这个时候aValue的值为0
         
*/
        template
<class T>
        
static bool TryStringToDWord(const T * paramNumberString, XDWord & paramValue)
        {
            paramValue 
= 0//设置初始值
            if( isNULL(paramNumberString) )
            {
                
return true;
            }
            
bool HexFlag = false;
            
const T *= paramNumberString;
            
//跳过导前空格
            while(*== ' ')
            {
                p
++;
            }
            
switch(*p) 
            {
            
case 0:
                
return false;
            
case '$':
            
case 'x':
            
case 'X':
                HexFlag 
= true;
                
++p;
                
break;
            
case '0':
                HexFlag 
= ((*(p+1== 'x'|| (*(p+1== 'X')); 
                
if (HexFlag) 
                {
                    p 
+= 2;
                }
                
break;
            }

            
if (*== 0
            {
                
return false;
            }

            XDWord dwValue 
= 0;
            
if (HexFlag)
            {
                
// DWord的十六进制字符串最多有8个字节
                if (Length(p) > 8
                {
                    
return false;
                }

                
while (*!= 0
                {
                    XDWord v;
                    T chNumber 
= *p;

                    
if (chNumber >= '0' && chNumber <= '9')    
                    {
                        v 
= chNumber - '0';
                    }
                    
else if (chNumber >= 'a' && chNumber <= 'f')
                    {
                        v 
= chNumber - 'a' + 10;
                    }
                    
else if (chNumber >= 'A' && chNumber <= 'F'
                    {
                        v 
= chNumber - 'A' + 10;
                    }
                    
else 
                    {
                        
return false;
                    }
                    dwValue 
*= 16;
                    dwValue 
+= v;
                    
++p;
                }
            }
            
else
            {
                
//  最大值是 4294967295 (0xFFFFFFFF)
                const XDWord ABS_MAX_DWORD_DIV10 = 429496729u;
                
const XDWord ABS_MAX_DWORD_MOD10 = 5u;

                
while (*!= 0)
                {
                    T chNumber 
= *p;
                    
//如果是无效数字
                    if (chNumber < '0' || chNumber > '9')
                    {
                        
return false;
                    }
                    
//如果将会超过最大除10整数
                    if( dwValue > ABS_MAX_DWORD_DIV10 )
                    {
                        
return false;
                    }

                    XDWord v 
= chNumber - '0';
                    
//如果将会超过最大整数
                    if (dwValue == ABS_MAX_DWORD_DIV10 && v > ABS_MAX_DWORD_MOD10) 
                    {
                        
return false;        
                    }
                    
//dwValue = dwValue * 10 + v;
                    dwValue *= 10;
                    dwValue 
+= v;
                    
++p;
                }
            }
            paramValue 
= dwValue;
            
return true;
        }

        
        
//----------------------------------------------------------------------------
        /**
              尝试将字符串转换为64位有符号整数,能够自动识别十进制和十六进制数。
              @param [in] paramNumberString 被转换的数值字符串
              @param [out] paramValue 用于保存转换后的数值
              @return 返回尝试转换的状态
                - true 表示转换成功
                - false 表示转换失败,这个时候aValue的值为0
         
*/
        template
<class T>
        
static bool TryStringToLong(const T * paramNumberString, XLong & paramValue)
        {
            
            paramValue 
= 0;

            
if( isNULL(paramNumberString) ) 
            {
                
return true;
            }

            
bool NegativeFlag = false;
            
bool HexFlag = false;

            
const T * p = paramNumberString;
            
//跳过空格
            while(*== ' '
            {
                p
++;
            }

            
switch(*p) 
            {
            
case 0:
                
return false;
            
case '+':
                
++p;
                
break;
            
case '-':
                NegativeFlag 
= true;
                
++p;
                
break;
            
case '$':
            
case 'x':
            
case 'X':
                HexFlag 
= true;
                
++p;
                
break;
            
case '0':
                HexFlag 
= ((*(p+1== 'x'|| (*(p+1== 'X'));
                
if (HexFlag) p += 2;
                
break;
            }

            
if (*== 0)
            {
                
return false;
            }
            XLong lngValue 
= 0;
            
if (HexFlag)
            {
                
// INT64的十六进制字符串最多有16个字节
                if (Length(p) > 16)    
                {
                    
return false;
                }

                
while (*!= 0
                {
                    XByte v;
                    T chNumber 
= * p;
                    
if (chNumber >= '0' && chNumber <= '9')
                    {
                        v 
= chNumber - '0';
                    }
                    
else if (chNumber >= 'a' && chNumber <= 'f'
                    {
                        v 
= chNumber - 'a' + 10;
                    }
                    
else if (chNumber >= 'A' && chNumber <= 'F'
                    {
                        v 
= chNumber - 'A' + 10;
                    }
                    
else
                    {
                        
return false;
                    }
                    
//lngValue = lngValue * 16 + v;
                    lngValue *= 16;
                    lngValue 
+= v;
                    
++p;
                }
            }
            
else
            {
                
//  整数最小值是 -9223372036854775808LL (0x8000000000000000), 最大值是 9223372036854775807LL (0x7FFFFFFFFFFFFFFF)
                const XLong ABS_MIN_LONG_INT_DIV10 = 922337203685477580LL;
                
const XLong ABS_MIN_LONG_INT_MOD10 = 8LL;
                
const XLong ABS_MAX_LONG_INT_DIV10 = 922337203685477580LL;
                
const XLong ABS_MAX_LONG_INT_MOD10 = 7LL;
                
const XLong ABS_MIN_LONG_INT_VALUE = 0x8000000000000000LL;
                
                
while (*!= 0)
                {
                    T chNumber 
= * p;
                    
if (chNumber < '0' || chNumber > '9')    
                    {
                            
return false;
                    }

                    XByte v 
= *- '0';

                    
if (NegativeFlag)
                    {
                        
if (lngValue > ABS_MIN_LONG_INT_DIV10)    
                        {
                            
return false;
                        }

                        
if (lngValue == ABS_MIN_LONG_INT_DIV10)
                        {
                            
if (v > ABS_MIN_LONG_INT_MOD10) 
                            {
                                
return false;
                            }

                            
// 因为需要intValue始终是正整数, 其最大值是 2147483647
                            
// 如果此时v=8, 将导致其溢出
                            if (v == ABS_MIN_LONG_INT_MOD10)
                            {
                                
// 如果后面没有字符了, 说明这个是最后一个字符, 那么这个数是整型最小值
                                
// 之所以在这里退出, 是为了防止整型最大值溢出
                                if (*(p+1== 0)
                                {
                                    paramValue 
= ABS_MIN_LONG_INT_VALUE;    
                                    
return true;
                                }
                                
else return false;
                            }
                        }
                    }
                    
else
                    {
                        
if (lngValue > ABS_MAX_LONG_INT_DIV10)    
                        {
                            
return false;
                        }
                        
if (lngValue == ABS_MAX_LONG_INT_DIV10 && v > ABS_MAX_LONG_INT_MOD10) 
                        {
                            
return false;
                        }
                    }
                    lngValue 
*= 10;
                    lngValue 
+= v;
                    
++p;
                }
            }
            paramValue 
= NegativeFlag ? -lngValue : lngValue;
            
return true;
        }
        
//----------------------------------------------------------------------------
        /**
              尝试将字符串转换为64位无符号整数,能够自动识别十进制和十六进制数。
              @param [in] paramNumberString 被转换的数值字符串
              @param [out] paramValue 用于保存转换后的数值
              @return 返回尝试转换的状态
                - true 表示转换成功
                - false 表示转换失败,这个时候aValue的值为0
         
*/
        template
<class T>
        
static bool TryStringToDDWord(const T * paramNumberString, XDDWord & paramValue)
        {
            paramValue 
= 0//设置初始值为0

            
if( isNULL(paramNumberString) ) 
            {
                
return true;
            }
            
bool HexFlag = false//定义十六进制标志符,默认为false。
            
            
const T *= paramNumberString;
            
//跳过空格
            while(*== ' '
            {
                p
++;
            }
            
//判断字符串为十进制的还是十六进制,并对hex赋值。
            switch(*p) 
            {
            
case 0:
                
return false;
            
case '$':
            
case 'x':
            
case 'X':
                HexFlag 
= true;
                
++p;
                
break;
            
case '0':
                HexFlag 
= ((*(p+1== 'x'|| (*(p+1== 'X')); 
                
if (HexFlag) p += 2;
                
break;
            }
            
            
if (*== 0
            {
                
return false;
            }

            XDDWord ddwValue 
= 0;
                
            
if (HexFlag)// 对十六进制数的字符串进行转换。
            {
                
// XDDWord的十六进制字符串最多有16个字节
                if (Length(p) > 16)    
                {
                    
return false;
                }
        
                
while (*!= 0
                {
                    XByte v;
                    T chNumber 
= *p;
                    
                    
if (chNumber >= '0' && chNumber <= '9')    
                    {
                        v 
= chNumber - '0';
                    }
                    
else if (chNumber >= 'a' && chNumber <= 'f')
                    {
                        v 
= chNumber - 'a' + 10;
                    }
                    
else if (chNumber >= 'A' && chNumber <= 'F')
                    {
                        v 
= chNumber - 'A' + 10;
                    }
                    
else 
                    {
                        
return false;
                    }
                    ddwValue 
*= 16;
                    ddwValue 
+= v;
                    
++p;
                }
            }
            
else//对十进制的数的字符串进行转换。
            {
                
// 最大值是 18446744073709551615LL (0xFFFFFFFFFFFFFFFF)

                
const XDDWord ABS_MAX_DDWORD_DIV10 = 1844674407370955161ULL;
                
const XDDWord ABS_MAX_DDWORD_MOD10 = 5ULL;
                
                
while (*!= 0)
                {
                    T chNumber 
= *p;

                    
if (chNumber < '0' || chNumber > '9'
                    {
                        
return false;
                    }
                    
                    XByte v 
= chNumber - '0';
                    
                    
if (ddwValue > ABS_MAX_DDWORD_DIV10) 
                    {
                        
return false;//转化后的整数值越界,则转化失败。
                    }
                        
                    
if (ddwValue == ABS_MAX_DDWORD_DIV10 && v > ABS_MAX_DDWORD_MOD10) 
                    {
                        
return false;
                    }
                    ddwValue 
*= 10;
                    ddwValue 
+= v;
                    
++p;
                }
                
//paramValue =  ddwValue;
            }
            paramValue 
= ddwValue;

            
return true;        
        }
        
//----------------------------------------------------------------------------
        /**
              尝试将字符串转换为32位有符号整数,能够自动识别十进制和十六进制数。
              @param [in] paramNumberString 被转换的数值字符串
              @param [in] paramDefault 缺少数值
              @return XInt 返回转换后的整数
         
*/
        template
<class T>
        inline XInt StringToIntDef(
const T * paramNumberString, XInt paramDefault = 0)
        {
            XInt iRet;
            
if!TryStringToInt(paramNumberString,iRet) ) 
            {
                iRet 
= paramDefault;
            }
            
return iRet;
        }
        
//----------------------------------------------------------------------------
        /**
              尝试将字符串转换为32位无符号整数,能够自动识别十进制和十六进制数。
              @param [in] paramNumberString 被转换的数值字符串
              @param [in] paramDefault 缺少数值
              @return XDWord 返回转换后的整数
         
*/
        template
<class T>
        inline XDWord StringToDWordDef(
const T * paramNumberString, XDWord paramDefault = 0)
        {
            XDWord dwRet;
            
if!TryStringToDWord(paramNumberString,dwRet) ) 
            {
                dwRet 
= paramDefault;
            }
            
return dwRet;
        }
        
//----------------------------------------------------------------------------
        /**
              尝试将字符串转换为64位有符号整数,能够自动识别十进制和十六进制数。
              @param [in] paramNumberString 被转换的数值字符串
              @param [in] paramDefault 缺少数值
              @return XLong 返回转换后的整数
         
*/
        template
<class T>
        inline XLong StringToLongDef(
const T * paramNumberString, XLong paramDefault = 0)
        {
            XLong lngRet;
            
if!TryStringToLong(paramNumberString,lngRet) ) 
            {
                lngRet 
= paramDefault;
            }
            
return lngRet;
        }
        
//----------------------------------------------------------------------------
        /**
              尝试将字符串转换为64位无符号整数,能够自动识别十进制和十六进制数。
              @param [in] paramNumberString 被转换的数值字符串
              @param [in] paramDefault 缺少数值
              @return XDDWord 返回转换后的整数
         
*/
        template
<class T>
        inline XDDWord StringToDDWordDef(
const T * paramNumberString, XDDWord paramDefault = 0)
        {
            XDDWord ddwRet;
            
if!TryStringToDDWord(paramNumberString,ddwRet) ) 
            {
                ddwRet 
= paramDefault;
            }
            
return ddwRet;
        }
        
///将字符串中的小写字符转换为大写字符
        /**
            @param [in,out] 被转换的字符串
            @return T * 转换后的字符串
                这里转换后的字符串与参数中的字符串相同
         
*/
        template
<class T>
        
static T * UpperCase(T * paramString)
        {
            ZDH_ASSERT(paramString 
!= NULL);
            T 
* pString = paramString;
            T ch;
            
do
            {
                ch 
= *pString;
                
if( ch <= 'z' && ch >= 'a' )
                {
                    
*pString = ch - 32;
                }
                pString
++;

            }
while(ch != 0);
            
return paramString;            
        }
        
///将字符串中的大写字符转换为小写字符
        /**
        @param [in,out] 被转换的字符串
        @return T * 转换后的字符串
        这里转换后的字符串与参数中的字符串相同
        
*/
        template
<class T>
        
static T * LowerCase(T * paramString)
        {
            ZDH_ASSERT(paramString 
!= NULL);
            T 
* pString = paramString;
            T ch;
            
do
            {
                ch 
= *pString;
                
if( ch <= 'Z' && ch >= 'A' )
                {
                    
*pString = ch + 32;
                }
                pString
++;

            }
while(ch != 0);
            
return paramString;    
        }
        
///去除字符串的左边空格
        /**
            请注意,请正确传入字符串的长度
            @param [in,out] paramString 被去除空格的字符串
            @param [in] paramLength 传入字符串的长度
            @return XInt 返回去除空格后,字符串的长度
         
*/
        template
<class T>
        
static XInt TrimLeft(T * paramString,XInt paramLength)
        {
            ZDH_ASSERT(Length(paramString) 
== paramLength);
            XInt iRet 
= 0;
            
if( paramLength > 0)
            {
                T 
* pStart = paramString;
                T 
* pEnd = paramString + paramLength - 1;
                
//找到第一个非空格字符串            
                while( pStart <= pEnd )
                {
                    
if!isSpaceTab(*pStart) ) break;
                    pStart 
++;
                }
                
//复制数据,并计算新字符串的长度
                T * pDest = paramString;
                iRet 
= (XInt)(pEnd + 1 - pStart);
                
while( pStart <= pEnd )
                {
                    
*pDest ++ = *pStart ++;
                }
                
//设置字符串结尾符
                *pDest = 0;
            }
            
return iRet;
        }
        
///去除字符串的右边空格
        /**
            请注意,请正确传入字符串的长度
            @param [in,out] paramString 被去除空格的字符串
            @param [in] paramLength 传入字符串的长度
            @return XInt 返回去除空格后,字符串的长度
         
*/
        template
<class T>
        
static XInt TrimRight(T * paramString,XInt paramLength)
        {
            ZDH_ASSERT(Length(paramString) 
== paramLength);
            XInt iRet 
= 0;
            
if( paramLength > 0)
            {
                T 
* pStart = paramString;
                T 
* pEnd = paramString + paramLength - 1;
                
//反向查找一个非空格字符
                while( pStart <= pEnd )
                {
                    
if!isSpaceTab(*pEnd) ) break;
                    pEnd 
--;
                }
                
*(pEnd + 1= 0;
                iRet 
= (XInt)(pEnd + 1 - pStart);
            }
            
//返回字符数
            return iRet;
        }
        
///清除左右两边的字符串
        /**
            请注意,请正确传入字符串的长度
            @param [in,out] paramString 被去除空格的字符串
            @param [in] paramLength 传入字符串的长度
            @return XInt 返回去除空格后,字符串的长度
         
*/
        template
<class T>
        
static XInt Trim(T * paramString,XInt paramLength)
        {
            ZDH_ASSERT(Length(paramString) 
== paramLength);
            XInt iRet 
= 0;
            
if( paramLength > 0)
            {
                T 
* pStart = paramString;
                T 
* pEnd = paramString + paramLength - 1;
                
while( pStart <= pEnd )
                {
                    
if!isSpaceTab(*pStart) ) break;
                    pStart 
++;
                }
                
while( pStart <= pEnd )
                {
                    
if!isSpaceTab(*pEnd) ) break;
                    pEnd 
--;
                }
                T 
* pDest = paramString;
                iRet 
= (XInt)(pEnd + 1 - pStart);
                
while( pStart <= pEnd )
                {
                    
*pDest ++ = *pStart ++;
                }
                
*pDest = 0;
            }
            
return iRet;
        }
        
///去除字符串的左边空格
        /**
            @param [in,out] paramString 被去除空格的字符串
            @return T * 返回去除空格后的字符串
         
*/
        template
<class T>
        
static T * TrimLeft(T * paramString)
        {
            XInt iLength 
= Length(paramString);
            
if( iLength > 0)
            {
                T 
* pStart = paramString;
                T 
* pEnd = paramString + iLength - 1;
                
while( pStart <= pEnd )
                {
                    
if!isSpaceTab(*pStart) ) break;
                    pStart 
++;
                }
                T 
* pDest = paramString;
                
while( pStart <= pEnd )
                {
                    
*pDest ++ = *pStart ++;
                }
                
*pDest = 0;
            }
            
return paramString;
        }
        
///去除字符串的右边空格
        /**
            @param [in,out] paramString 被去除空格的字符串
            @return T * 返回去除空格后的字符串
         
*/
        template
<class T>
        
static T * TrimRight(T * paramString)
        {
            XInt iLength 
= Length(paramString);
            
if( iLength > 0)
            {
                T 
* pStart = paramString;
                T 
* pEnd = paramString + iLength - 1;
                
while( pStart <= pEnd )
                {
                    
if!isSpaceTab(*pEnd) ) break;
                    pEnd 
--;
                }
                
*(pEnd + 1= 0;
            }
            
return paramString;
        }
        
///去除字符串的左右两边空格
        /**
            @param [in,out] paramString 被去除空格的字符串
            @return T * 返回去除空格后的字符串
         
*/
        template
<class T>
        
static T * Trim(T * paramString)
        {
            XInt iLength 
= Length(paramString);
            
if( iLength > 0)
            {
                T 
* pStart = paramString;
                T 
* pEnd = paramString + iLength - 1;
                
while( pStart <= pEnd )
                {
                    
if!isSpaceTab(*pStart) ) break;
                    pStart 
++;
                }
                
while( pStart <= pEnd )
                {
                    
if!isSpaceTab(*pEnd)) break;
                    pEnd 
--;
                }
                T 
* pDest = paramString;
                
while( pStart <= pEnd )
                {
                    
*pDest ++ = *pStart ++;
                }
                
*pDest = 0;
            }
            
return paramString;
        }


        
namespace private_impl
        {

            
//请不要直接这里定义的函数
            ///复制内存
            template<class T>
            
static T * _MemoryCopy(T * paramMemoryDest, const T* paramMemorySrc, XInt paramCopySize)
            {
                XInt iCopyBytes 
= paramCopySize;
                
const XDDWord * pS = (const XDDWord *)paramMemorySrc;
                XDDWord 
* pD = (XDDWord *)paramMemoryDest;
                
for(XInt i = iCopyBytes / sizeof(XDDWord); i > 0; i--, pS ++, pD++ )
                {
                    
*pD = *pS;
                }            
                XByte 
* pBS = (XByte *)pS;
                XByte 
* pBD = (XByte *)pD;
                
for(XInt i = iCopyBytes % sizeof(XDDWord); i > 0; i--, pBS ++, pBD++ )
                {
                    
*pBD = *pBS;
                }
                
return paramMemoryDest;
            }
            
///初始化内存
            template<class T>
            
static void * _MemorySet(T * paramMemory, XInt paramMemorySize, XInt paramValue)
            {
                
if( paramMemorySize > 16)  //如果大于16字节,就做优化,以8字节的速度复制
                {
                    
//初始化要复制的数据
                    union 
                    {
                        XDDWord ddwV;
                        XByte btV[
sizeof(XDDWord)];
                    }temp;
                    {
                        XByte 
* pDest = temp.btV;
                        
for(XInt i = 0; i < sizeof(temp.btV); i++ )
                        {
                            
*pDest ++ = (XByte)paramValue;
                        }
                    }

                    {
                        
//复制
                        XInt iCopyCount = paramMemorySize / sizeof(XDDWord);
                        XDDWord 
* pDest = (XDDWord *)paramMemory;
                        
while(iCopyCount > 0)
                        {
                            
*pDest ++ = temp.ddwV;
                            iCopyCount 
--;
                        }
                        iCopyCount 
= paramMemorySize % sizeof(XLong);
                        XByte 
* pByteDest = (XByte *)pDest;
                        
while(iCopyCount > 0)
                        {
                            
*pByteDest ++ = (XByte)paramValue;
                        }
                    }
                }
                
else if( paramMemorySize > 0 )
                {
                    XByte 
* pDest = (XByte *)paramMemory;
                    XByte btValue 
= (XByte)paramValue;
                    
for(XInt i = 0; i < paramMemorySize; i++)
                    {
                        
*pDest ++ = btValue;
                    }
                }
                
return paramMemory;
            }
            template
<class T>
            
static T * _MemoryMove(T * paramMemoryDest, const T * paramMemorySrc, XInt paramMoveSize)
            {
                
//检查是否有重叠
                XInt iDis = XInt(((XByte *)paramMemoryDest) - ((XByte *)paramMemorySrc));
                
if( iDis > 0 && iDis < paramMoveSize ) //如果存在重叠现象
                {
                    XDDWord 
* pS = (XDDWord *)(((XByte *)paramMemorySrc) + paramMoveSize);
                    XDDWord 
* pD = (XDDWord *)(((XByte *)paramMemoryDest) + paramMoveSize);
                    XInt iCopyCount 
= paramMoveSize / sizeof(XDDWord);
                    
while(iCopyCount > 0)
                    {
                        pS
--;
                        pD
--;
                        
*pD = *pS;
                        iCopyCount 
--;
                    }
                    iCopyCount 
= paramMoveSize % sizeof(XDDWord);
                    XByte 
* pBS = (XByte *)pS;
                    XByte 
* pBD = (XByte *)pD;
                    
while(iCopyCount > 0)
                    {
                        pBS
--;
                        pBD
--;
                        
*pBD = *pBS;
                        iCopyCount 
--;
                    }
                }
                
else
                {
                    
return _MemoryCopy(paramMemoryDest, paramMemorySrc, paramMoveSize);
                }
                
return paramMemoryDest;
            }
        }
        
///将内存初始化为0
        inline void * MemoryZero(void * paramMemory, XInt paramSize)
        {
            ZDH_ASSERT(paramMemory 
!= NULL);
            ZDH_ASSERT(paramSize 
>= 0);
            
return private_impl::_MemorySet(paramMemory, paramSize, 0);
        }
        
///重置内存
        inline void * MemorySet(void * paramMemory, XInt paramSize, XInt paramValue)
        {
            ZDH_ASSERT(paramMemory 
!= NULL);
            ZDH_ASSERT(paramSize 
>= 0);
            
return private_impl::_MemorySet(paramMemory, paramSize, paramValue);
        }
        
///复制内存
        inline void * MemoryCopy(void * paramDest,const void * paramSrc, XInt paramCopySize)
        {
            ZDH_ASSERT(paramDest 
!= NULL);
            ZDH_ASSERT(paramSrc 
!= NULL);
            ZDH_ASSERT(paramCopySize 
>= 0);
            
return private_impl::_MemoryCopy(paramDest, paramSrc, paramCopySize);
        }
        
///移动内存
        inline void * MemoryMove(void * paramDest, const void * paramSrc, XInt paramMoveSize)
        {
            ZDH_ASSERT(paramDest 
!= NULL);
            ZDH_ASSERT(paramSrc 
!= NULL);
            ZDH_ASSERT(paramMoveSize 
>= 0);
            
return private_impl::_MemoryMove(paramDest, paramSrc, paramMoveSize);
        }
        
///字符串复制
        /**
            @param [out] paramDest 存放要复制字符串的指针
            @param [in] paramSrc 源字符串的指针
            @reutrn T * 返回存放复制字符串后指针
         
*/
        template
<class T>
        
static T * StringCopy(T * paramDest, const T * paramSrc)
        {
            ZDH_ASSERT(paramDest 
!= NULL);
            ZDH_ASSERT(paramSrc 
!= NULL);
            T 
* pT = paramDest;
            
while*paramSrc )
            {
                
*pT ++ = * paramSrc++;
            }
            
*pT = 0;
            
return paramDest;
        }
        
///字符串复制(指定最大复制字符数
        /**
            @param [out] paramDest 存放要复制字符串的指针
            @param [in] paramSrc 源字符串的指针
            @param [in] paramN 最大复制的字符数
            @reutrn T * 返回存放复制字符串后指针
         
*/
        template
<class T>
        
static T * StringCopy(T * paramDest, const T * paramSrc,const XInt paramN)
        {
            ZDH_ASSERT(paramDest 
!= NULL);
            ZDH_ASSERT(paramSrc 
!= NULL);
            ZDH_ASSERT(paramN 
>= 0);
            XInt iN 
= paramN;
            T 
* pT = paramDest;
            
while*paramSrc && iN > 0 )
            {
                
*pT ++ = * paramSrc++;
                iN
--;
            }
            
*pT = 0;
            
return paramDest;
        }

    }; 
/* namespace string_utils */
    
    
///字符串基础模板
    template<class T = XChar,class Alloctor = XMemory>
    
class XStringBase
    {
    
public:
        
enum
        {
            npos 
= -1
        };
    
public:
        typedef T StringChar;
        typedef T 
* TPointer;
        typedef 
const T * ConstTPointer;
    
private:
        
///字符串结构结构体
        struct SStringStruct
        {
            XInt Length;        
///<尺寸
            XInt Capacity;        ///<当前字符串的容量
            //Data                ///<当前数据指针所在的位置
        };
        //字符串内的常量定义,不给外部使用的
        enum 
        { 
            STRING_BLOCK_SIZE 
= 64,                //单位块大小
            CHAR_SIZE = sizeof(T),                //每个字符串的大小
            HEAD_SIZE = sizeof(SStringStruct),    //字符串头的字节数
            XSTRING_BASE_ENUM_FORCE_DWORD = 0x7FFFFFFF //强制该Enum为32位
        };    //字符串最小内存块大小
    public:
        
///默认构造函数
        XStringBase() 
            :m_Data(NULL) 
        {}
        
///构造函数
        XStringBase(const T * paramString)
            :m_Data(NULL)
        {
            XInt iLength 
= string_utils::Length(paramString);
            
if( iLength > 0)
            {
                ensureCapacity(iLength);
                CopyData(paramString, (T 
*)m_Data, iLength);
                getOriData()
->Length = iLength;
            }
        }
        
///默认拷贝构造函数
        XStringBase(const XStringBase<T> & paramString)
            :m_Data(NULL)
        {
            XInt iLength 
= paramString.getLength();
            
if( iLength > 0)
            {
                ensureCapacity(iLength);
                CopyData(paramString.c_str(), (T 
*)m_Data, iLength);
                getOriData()
->Length = iLength;
            }
        }
        
///构造函数
        XStringBase(const T & paramChar)
            :m_Data(NULL)
        {
            ensureCapacity(
1);
            
*((T *)m_Data) = paramChar;
            
*(((T *)m_Data) + 1= 0;
            getOriData()
->Length = 1;

        }
        
///析构函数
        ~XStringBase()
        {
            
if( isNotNULL(m_Data) )
            {
                Alloctor::Free(getOriData());
                m_Data 
= NULL;
            }
        }
        
///取字符串最小块的字节数
        XInt getBlockBytes() const { return STRING_BLOCK_SIZE; }
        
///取字符的字节数
        XInt getCharBytes() const { return CHAR_SIZE; }
        
///取当前容量
        XInt getCapacity() const
        {
            XInt iRet 
= 0;
            
if( isNotNULL(m_Data) ) 
            {
                iRet 
= getOriData()->Capacity;
            }
            
return iRet;
        }
        
///取当前字符串的长度
        XInt getLength() const
        {
            XInt iRet 
= 0;
            
if( isNotNULL(m_Data) )
            {
                iRet 
= getOriData()->Length;
            }
            
return iRet;
        }
        
///取数组的最大容量
        XInt getMaxCapacity() const { return (0x7ffffff0 - HEAD_SIZE) / CHAR_SIZE;    }
        
///确定装载字符容量(会自动增加0结尾)
        void ensureCapacity(XInt paramCharCapacity)
        {
            
if( paramCharCapacity > 0)
            {
                expandCapacity(paramCharCapacity 
+ 1); //增加一个字符0的位置
            }
        }
        
///取字符串的内容
        const T * c_str() const
        {
            
static T sNullString[1= {0};
            
if( isNULL(m_Data) ) 
            {
                
return sNullString;
            }
            
else 
            {
                
return (const T *)m_Data;
            }
        }
        
///判断当前字符串是否为空
        bool isEmpty() const { return getLength() == 0; }
        
bool isNotEmpty() const { return getLength() != 0; }
        
///取字符串指针函数
        const void * Data() const {    return m_Data; }
        
///赋值函数
        /**
            将当前串设为指定的串
         
*/
        
void Assign(const XStringBase<T> & paramR)
        {
            
if&paramR != this )
            {
                Assign(paramR.c_str(), paramR.getLength());
            }
        }
        
///赋值函数
        /**
            将当前串设为指定的串    
         
*/
        
void Assign(const T * paramR)
        {
            ZDH_ASSERT(paramR 
!= NULL);
            XInt iLength 
= string_utils::Length(paramR);
            Assign(paramR, iLength);
        }
        
///赋值函数
        /**
            将当前串设为指定的串    
            @param [in] paramR 指定的串
            @param [in] paramLength 指定串的长度
         
*/
        
void Assign(const T * paramR, XInt paramLength)
        {
            
if( c_str() == paramR ) return;
            XInt iLength 
= paramLength;
            
if( iLength > 0)
            {
                ensureCapacity(iLength
+1);
                CopyData(paramR, (T 
*)m_Data, iLength);
                getOriData()
->Length = iLength;
            }
            
else
            {
                ToEmptyString();
            }
        }
        
///赋值函数
        /**
            将当前串设为只有指定字符的串    
         
*/
        
void Assign(const T & paramR)
        {
            
if( paramR != 0 )
            {
                ensureCapacity(
1);
                
*((T *)m_Data)  = paramR;
                
*(((T *)m_Data) + 1= 0;
                getOriData()
->Length = 1;
            }
            
else
            {
                ToEmptyString();
            }
        }
        
///追加指定的字符串
        void AppendString(const XStringBase<T> & paramR)
        {
            XInt iLength 
= paramR.getLength();
            
if( iLength > 0)
            {
                XInt iThisLength 
= getLength();
                ensureCapacity(iThisLength 
+ iLength);
                CopyData(paramR.c_str(), ((T 
*)m_Data) + iThisLength, iLength);
                getOriData()
->Length = iLength + iThisLength;
            }
        }
        
///追加指定的字符串
        void AppendString(const XStringBase<T> & paramR,XInt paramCount)
        {
            XInt iLength 
= paramR.getLength();
            
if( iLength > 0 && paramCount > 0)
            {
                XInt iThisLength 
= getLength();
                ensureCapacity(iThisLength 
+ (iLength * paramCount));
                T 
* p = ((T *)m_Data) + iThisLength;
                
const T * s = paramR.c_str();
                
for(XInt i = 0; i < paramCount; i++)
                {
                    CopyData(s, p, iLength);
                    p 
+= iLength;

                }
                getOriData()
->Length = (iLength * paramCount )+ iThisLength ;
            }
        }
        
///追加指定的字符串
        void AppendString(const T * paramR)
        {
            AppendString(paramR, string_utils::Length(paramR));
        }
        
///追加指定长度的字符串
        void AppendString(const T * paramR, XInt paramLength)
        {
            XInt iLength 
= paramLength;//string_utils::Length(paramR);
            if( iLength > 0 && paramR != NULL )
            {
                XInt iThisLength 
= getLength();
                ensureCapacity(iThisLength 
+ iLength);
                CopyData(paramR, ((T 
*)m_Data) + iThisLength, iLength);
                getOriData()
->Length = iLength + iThisLength;
            }
        }
        
void AppendString(const T * paramR, XInt paramLength, XInt paramCount)
        {
            XInt iLength 
= paramLength;
            
if( iLength > 0 && paramR != NULL && paramCount > 0 )
            {
                XInt iThisLength 
= getLength();
                ensureCapacity(iThisLength 
+ (iLength * paramCount));
                T 
* p = ((T *)m_Data) + iThisLength;
                
for(XInt i = 0; i < paramCount; i++)
                {
                    CopyData(paramR, p, iLength);
                    p 
+= iLength;
                }
                getOriData()
->Length = (iLength * paramCount)+ iThisLength;
            }
        }
        
///追加一个字符
        void AppendChar(const T paramR)
        {
            AppendChar(paramR,
1);
        }
        
///追加指定个数的字符
        /**
            字符'\0'不能被加入
            @param [in] paramR 要追加的字符
            @param [in] paramCount 要追加的个数
         
*/
        
void AppendChar(const T paramR, XInt paramCount)
        {
            
if( paramR != 0 && paramCount > 0 )
            {
                XInt iThisLength 
= getLength();
                ensureCapacity(iThisLength 
+ paramCount);
                T 
* p = ((T *)m_Data) + iThisLength;
                
for(XInt i = 0; i < paramCount; i++)
                {
                    
*p++ = paramR;
                }
                
*= 0;
                getOriData()
->Length = iThisLength + paramCount;                
            }
        }
        
///取指定下标的字符
        /**
            @param [in] paramIndex 指定的下标,有效范围是[0,getLength()-1];
         
*/
        T at(XInt paramIndex) 
const;
        
///取指定下标的字符引用
        /**
            @param [in] paramIndex 指定的下标,有效范围是[0,getLength()-1];
         
*/
        T 
& at(XInt paramIndex);
        
///检查指定的下标是否有效
        bool CheckIndex(XInt iIndex) const
        {
            
return iIndex >= 0 && iIndex < getLength();
        }
        
///查找子串的位置
        /**
            如果子串存在,则返回子串的下标,有效下标在[0,getLength()-1]之间;
            如果子串为空,则返回-1;
            @param [in] paramSubString 子串
            @return XInt 返回子串的下标
                - -1 表示未找到子串
                - >=0 表示返回对应子串的下标

         
*/
        XInt Pos(
const XStringBase<T> & paramSubString) const
        {
            
return Pos(0,paramSubString);
        }
        
///查找子串的位置
        /**
            如果子串存在,则返回子串的下标,有效下标在[0,getLength()-1]之间;
            如果子串为空,则返回-1;
            @param [in] paramSubString 子串
            @return XInt 返回子串的下标
                - -1 表示未找到子串
                - >=0 表示返回对应子串的下标

         
*/
        XInt Pos(
const T * paramSubString) const
        {
            
return Pos(0, paramSubString, string_utils::Length(paramSubString));
        }
        
///查找子串的位置
        /**
            如果子串存在,则返回子串的下标,有效下标在[0,getLength()-1]之间;
            如果子串为空,则返回-1;
            @param [in] paramSubString 子串
            @param [in] paramSubStringLength 子串的长度 
            @return XInt 返回子串的下标
                - -1 表示未找到子串
                - >=0 表示返回对应子串的下标

         
*/
        XInt Pos(
const T * paramSubString, XInt paramSubStringLength) const
        {
            
return Pos(0, paramSubString, paramSubStringLength);
        }
        
///查找子串的位置
        /**
            如果子串存在,则返回子串的下标,有效下标在[0,getLength()-1]之间;
            如果子串为空,则返回-1;
            @param [in] paramStartPos 开始的下标
            @param [in] paramSubString 子串
            @param [in] paramSubStringLength 子串的长度 
            @return XInt 返回子串的下标
                - -1 表示未找到子串
                - >=0 表示返回对应子串的下标

         
*/
        XInt Pos(XInt paramStartPos, 
const T * paramSubString, XInt paramSubStringLength) const
        {
            ZDH_ASSERT(paramSubString 
!= NULL);
            ZDH_ASSERT(paramSubStringLength 
== string_utils::Length(paramSubString));
            
if(isEmpty() || paramSubStringLength== 0)
            {
                
return -1;
            }
            
if( paramStartPos < 0 ) 
            {
                paramStartPos 
= 0;
            }
            
else if( paramStartPos >= getLength() ) 
            {
                
return -1;
            }
            
const T * s1 = c_str() + paramStartPos;
            
const T * s2 = paramSubString;
            
const T * pFind = FindString( s1, s2 );
            
if( isNULL(pFind) ) 
            {
                
return -1;
            }
            
return (XInt(pFind - s1) + paramStartPos);
        }
        
///从指定开始的位置,查找子串的位置
        /**
            如果子串存在,则返回子串的下标,有效下标在[0,getLength()-1]之间;
            如果子串为空,则返回-1;
            @param [in] paramStartPos 开始的位置
            @param [in] paramSubString 子串
            @return XInt 返回子串的下标
                - -1 表示未找到子串
                - >=0 表示返回对应子串的下标

         
*/
        XInt Pos(
const XInt paramStartPos, const XStringBase<T> & paramSubString) const
        {
            
return Pos(paramStartPos, paramSubString.c_str(), paramSubString.getLength());
        }
        
///确定字符的位置
        /**
            如果字符为0,则返回-1
            如果字符存在,则返回字符的下标,有效下标在[0,getLength()-1]之间;
            @param [in] paramChar 要查找的字符
            @return XInt 返回字符的下标
                - -1 表示未找到字符
                - >=0 表示返回对应字符的下标
         
*/
        XInt Pos(
const T & paramChar) const
        {
            
if( isEmpty() ) return -1;
            
if( paramChar == 0 ) return -1;
            
const T * s1 = c_str();
            T s2[
2];
            s2[
0= paramChar;
            s2[
1= 0;
            
const T * pFind = FindString( s1, s2 );
            
if( isNULL(pFind) ) return -1;
            
return XInt(pFind - s1);
        }
        
///从指定开始的位置,查找字符
        /**
            @param [in] paramStartPos 指定开始的位置,从0开始
            @param [in] paramChar 查找的字符
            @return XInt 返回字符的下标
                - -1 表示未找到字符
                - >=0 表示返回对应字符的下标
         
*/
        XInt Pos(
const XInt paramStartPos, const T & paramChar) const
        {
            
if( paramStartPos < 0 ) 
            {
                
return Pos(paramChar);
            }
            
else if( paramStartPos >= getLength() ) 
            {
                
return -1;
            }
            
const T * s1 = c_str() + paramStartPos;
            T s2[
2];
            s2[
0= paramChar;
            s2[
1= 0;
            
const T * pFind = FindString( s1, s2 );
            
if( isNULL(pFind) ) return -1;
            
return ((XInt)(pFind - s1)) + paramStartPos;
        }
        
///替换字符
        /**
            @param [in] paramFindChar 查找的字符
            @param [in] paramDestChar 要被替换成的字符
            @return XInt 被替换的字符个数
         
*/
        XInt ReplaceChar(
const T &paramFindChar, const T & paramDestChar)
        {
            ZDH_ASSERT(paramFindChar 
!= paramDestChar);
            XInt iRetReplaceCount 
= 0;
            XInt iLength 
= getLength();
            
if( paramDestChar != paramFindChar && iLength > 0 )
            {
                T 
* pData = (T *)m_Data;
                
for(XInt i = 0; i < iLength; i++, pData ++)
                {
                    
if* pData == paramFindChar )
                    {
                        iRetReplaceCount 
++;
                        
*pData = paramDestChar;
                    }
                }
            }
            
return iRetReplaceCount;
        }
        
///指定位置字符串
        /**
            @param [in] paramPos 插入的位置
            @param [in]    paramInsertString 插入的字符串
         
*/
        
void InsertString(XInt paramPos, const XStringBase<T> & paramInsertString, XInt paramInsertCount = 1)
        {
            InsertString(paramPos, paramInsertString.c_str(), paramInsertString.getLength(),paramInsertCount);
        }
        
///指定位置字符串
        /**
            @param [in] paramPos 插入的位置
            @param [in]    paramInsertString 插入的字符串
         
*/
        
void InsertString(XInt paramPos, const T * paramInsertString, XInt paramInsertCount = 1)
        {
            InsertString(paramPos, paramInsertString, string_utils::Length(paramInsertString),paramInsertCount);
        }
        
///指定位置字符串
        /**
            @param [in] paramPos 插入的位置
            @param [in]    paramInsertString 插入的字符串
            @param [in] paramInsertLength 要插入的字符串的长度
            @param [in] paramInsertCount 反复插入串的次数,默认为1
         
*/
        
void InsertString(XInt paramPos, const T * paramInsertString, XInt paramInsertLength, XInt paramInsertCount)
        {
            ZDH_ASSERT(paramInsertString 
!= NULL);
            ZDH_ASSERT(paramInsertLength 
>= 0);
            ZDH_ASSERT(paramInsertLength 
== string_utils::Length(paramInsertString));
            
if( paramInsertCount <=0 ) return;
            XInt iLength 
= getLength();
            XInt iInsertLength 
= paramInsertLength;
            XInt iAllInsertLength 
= iInsertLength * paramInsertCount;
            
if( iInsertLength > 0//如果有要插入的数据
            {
                
if( paramPos < 0 ) paramPos = 0;
                ensureCapacity(iLength 
+ iAllInsertLength);
                
if( paramPos >= iLength ) 
                {
                    
for(XInt i = 0; i < paramInsertCount; i++)
                    {
                        AppendString(paramInsertString, iInsertLength);
                    }
                }
                
else
                {
                    T 
* p = (T *)Data();
                    
//移动
                    T * pDest = p + iLength + iAllInsertLength; //最后的地址
                    T * pSrc = p + iLength;
                    T 
* pMove = p + paramPos;
                    
while( pSrc >= pMove )
                    {
                        
*pDest-- = *pSrc --;
                    }
                    
//插入
                    for(XInt j = 0; j < paramInsertCount; j++)
                    {
                        
const T * pInsert = paramInsertString;
                        
for(XInt i = 0; i < iInsertLength; i++)
                        {
                            
*pMove ++ = *pInsert++;
                        }
                    }
                    getOriData()
->Length = iLength + iAllInsertLength;                    
                }
            }
        }

        
///查询替换子串
        /**
            @param [in] paramSubString 要被替换的子串
            @param [in] paramDestString 要被换成的字符串
            @param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
            @return XInt 实际替换的次数
         
*/
        XInt ReplaceString(
const T * paramSubString, const T * paramDestString, XInt paramMaxReplaceCount = -1)
        {
            ZDH_ASSERT(paramSubString 
!= NULL );
            ZDH_ASSERT(paramDestString 
!= NULL );
            
return ReplaceString( 0, paramSubString, string_utils::Length(paramSubString), paramDestString, string_utils::Length( paramDestString), paramMaxReplaceCount );
        }
        
///查询替换子串
        /**
            @param [in] paramSubString 要被替换的子串
            @param [in] paramDestString 要被换成的字符串
            @param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
            @return XInt 实际替换的次数
         
*/
        XInt ReplaceString(
const XStringBase<T> & paramSubString, const XStringBase<T> & paramDestString, XInt paramMaxReplaceCount = -1)
        {
            
return ReplaceString( 0, paramSubString.c_str(), paramSubString.getLength(), paramDestString.c_str(), paramDestString.getLength(), paramMaxReplaceCount);
        }
        
///查询替换子串
        /**
            @param [in] paramStartPos 开始查找替换的位置
            @param [in] paramSubString 要被替换的子串
            @param [in] paramDestString 要被换成的字符串
            @param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
            @return XInt 实际替换的次数
         
*/
        XInt ReplaceString(XInt paramStartPos, 
const T * paramSubString, const T * paramDestString, XInt paramMaxReplaceCount = -1)
        {
            ZDH_ASSERT(paramSubString 
!= NULL );
            ZDH_ASSERT(paramDestString 
!= NULL );
            
return ReplaceString( paramStartPos, paramSubString, string_utils::Length(paramSubString), paramDestString, string_utils::Length( paramDestString), paramMaxReplaceCount );
        }
        
///查询替换子串
        /**
            @param [in] paramStartPos 开始查找替换的位置
            @param [in] paramSubString 要被替换的子串
            @param [in] paramDestString 要被换成的字符串
            @param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
            @return XInt 实际替换的次数
         
*/
        XInt ReplaceString(XInt paramStartPos, 
const XStringBase<T> & paramSubString, const XStringBase<T> & paramDestString, XInt paramMaxReplaceCount = -1)
        {
            
return ReplaceString( paramStartPos, paramSubString.c_str(), paramSubString.getLength(), paramDestString.c_str(), paramDestString.getLength(), paramMaxReplaceCount);
        }
        
///查询替换子串
        /**
            @param [in] paramStartPos 开始查找替换的位置
            @param [in] paramSubString 要被替换的子串
            @param [in] paramSubStringLength 子串的长度
            @param [in] paramDestString 要被换成的字符串
            @param [in] paramDestStringLength 要被换成的字符串的长度
            @param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
            @return XInt 实际替换的次数
         
*/
        XInt ReplaceString(XInt paramStartPos, 
const T * paramSubString, XInt paramSubStringLength, const T * paramDestString, XInt paramDestStringLength, XInt paramMaxReplaceCount = -1)
        {
            ZDH_ASSERT(paramSubString 
!= NULL);
            ZDH_ASSERT(paramDestString 
!= NULL);
            ZDH_ASSERT(paramSubStringLength 
== string_utils::Length(paramSubString));
            ZDH_ASSERT(paramDestStringLength 
== string_utils::Length(paramDestString));
            XInt iRet 
= 0;    //返回替换的次数
            XInt iStart = paramStartPos;    //开始替换的位置
            XInt iBegin = 0;                //要保留字符串的起始位置
            XStringBase<T> strTemp;            //临时用的字符串
            XInt iLocalLength = getLength();    //当前字符串的长度
            strTemp.ensureCapacity( iLocalLength );
            XInt iPos 
= Pos(iStart, paramSubString, paramSubStringLength ); //第一次查找
            
//当找到子串,并且替换次数小于最大替换次数或者无限替换次数
            while(iPos >= 0 && ((paramMaxReplaceCount > 0 && iRet < paramMaxReplaceCount) || paramMaxReplaceCount < 0) )
            {
                iRet 
++;
                XInt iCopyLength 
= iPos - iBegin; //确定要复制的字符串
                if( iCopyLength > 0 )
                {
                    strTemp.AppendString( c_str() 
+ iBegin, iCopyLength, 1); 
                }
                
if( paramDestStringLength > 0)
                {
                    strTemp.AppendString( paramDestString, paramDestStringLength, 
1);
                }
                iStart 
= iBegin = iPos + paramSubStringLength;
                
                iPos 
= Pos(iStart, paramSubString, paramSubStringLength);
            }
            
if( iRet > 0//如果发生了替换
            {
                XInt iCopyLength 
= iLocalLength - iBegin;
                
if( iCopyLength > 0 )
                {
                    strTemp.AppendString( c_str() 
+ iBegin, iCopyLength, 1);
                }
                Swap(strTemp);
            }
            
return iRet;
        }
        
///将字符转换成32位有符号整数
        /**
            如果字符串是无效整数,将会抛出异常XEConvert。
            字符串支持8,10,16进制整数
         
*/
        XInt ToInt() 
const;
        
///将字符转换成32位有符号整数
        /**
            字符串支持8,10,16进制整数
            @param [out] paramResult 存放转换的结果
            @return bool 转换结果
                - true 表示转换成功
                - false 表示转换失败
         
*/
        
bool ToInt(XInt & paramResult) const
        {
            
return string_utils::TryStringToInt(c_str(),paramResult);
        }
        
///将字符转换成32位有符号整数
        /**
            如果字符串是无效整数,将会返回指定的缺省值。
            字符串支持8,10,16进制整数
            @param [in] paramDefault 转换失败的缺省值
         
*/
        XInt ToIntDef(XInt paramDefault) 
const
        {
            
return string_utils::StringToIntDef(c_str(),paramDefault);
        }
        
///将字符转换成32位无符号整数
        /**
            如果字符串是无效整数,将会抛出异常XEConvert。
            字符串支持8,10,16进制整数
         
*/
        XDWord ToDWord() 
const;
        
///将字符转换成32位无符号整数
        /**
            字符串支持8,10,16进制整数
            @param [out] paramResult 存放转换的结果
            @return bool 转换结果
                - true 表示转换成功
                - false 表示转换失败
         
*/
        
bool ToDWord(XDWord & paramResult) const
        {
            
return string_utils::TryStringToDWord(c_str(), paramResult);
        }
        
///将字符转换成32位无符号整数
        /**
            如果字符串是无效整数,将会返回指定的缺省值。
            字符串支持8,10,16进制整数
            @param [in] paramDefault 转换失败的缺省值
         
*/
        XDWord ToDWordDef(XDWord paramDefault) 
const
        {
            
return string_utils::StringToDWordDef(c_str(),paramDefault);
        }
        
///将字符转换成64位有符号整数
        /**
            如果字符串是无效整数,将会抛出异常XEConvert。
            字符串支持8,10,16进制整数
         
*/
        XLong ToLong() 
const;
        
///将字符转换成64位有符号整数
        /**
            字符串支持8,10,16进制整数
            @param [out] paramResult 存放转换的结果
            @return bool 转换结果
                - true 表示转换成功
                - false 表示转换失败
         
*/
        
bool ToLong(XLong & paramResult) const
        {
            
return string_utils::TryStringToLong(c_str(), paramResult);
        }
        
///将字符转换成64位有符号整数
        /**
            如果字符串是无效整数,将会返回指定的缺省值。
            字符串支持8,10,16进制整数
            @param [in] paramDefault 转换失败的缺省值
         
*/
        XLong ToLongDef(XLong paramDefault) 
const
        {
            
return string_utils::StringToLongDef(c_str(),paramDefault);
        }
        
///将字符转换成64位无符号整数
        /**
            如果字符串是无效整数,将会抛出异常XEConvert。
            字符串支持8,10,16进制整数
         
*/
        XDDWord ToDDWord() 
const;
        
///将字符转换成64位无符号整数
        /**
            字符串支持8,10,16进制整数
            @param [out] paramResult 存放转换的结果
            @return bool 转换结果
                - true 表示转换成功
                - false 表示转换失败
         
*/
        
bool ToDDWord(XDWord & paramResult) const
        {
            
return string_utils::TryStringToDDWord(c_str(), paramResult);
        }
        
///将字符转换成64位无符号整数
        /**
            如果字符串是无效整数,将会返回指定的缺省值。
            字符串支持8,10,16进制整数
            @param [in] paramDefault 转换失败的缺省值
         
*/
        XDDWord ToDDWordDef(XDDWord paramDefault) 
const
        {
            
return string_utils::StringToDDWordDef(c_str(), paramDefault);
        }
        
///比较函数
        /**
            @param [in] paramR 参考比较的函数
            @return XInt 返回比较结果
                - 0 表示this == paramR
                > 0 表示this > paramR
                < 0    表示this < paramR
         
*/
        XInt Compare(
const XStringBase<T>& paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str());
        }
        
///忽略大小写比较函数
        /**
            @param [in] paramR 参考比较的函数
            @return XInt 返回比较结果
                - 0 表示this == paramR
                > 0 表示this > paramR
                < 0    表示this < paramR
         
*/
        XInt CompareIC(
const XStringBase<T>& paramR) const //ignorecase
        {
            
return string_utils::CompareIC(c_str(),paramR.c_str());
        }
        
///设为空串
        void ToEmptyString()
        {
            
if( getCapacity() > 0)
            {
                
*((T *)m_Data) = 0;
                getOriData()
->Length = 0;
            }
        }
        
///字符串交换
        void Swap(XStringBase<T> & paramR)
        {
            
void * pTemp = m_Data;
            m_Data 
= paramR.m_Data;
            paramR.m_Data 
= pTemp;
        }
        
///在当前的字符串中,删除指定的字符
        /**
            @param [in] paramCh 要删除的字符
            @return XInt 删除字符的个数
         
*/
        XInt RemoveChar(T paramCh)
        {
            XInt iFoundCount 
= 0;
            
if( isNotEmpty() ) 
            {
                T 
* pSrc = (T *)c_str();
                T 
* pDest = pSrc;
                XInt iLength 
= getLength(); 

                
                
while(iLength > 0)
                {
                    T ch 
= *pSrc++;
                    
if( ch == paramCh )
                    {
                        iFoundCount 
++;
                    }
                    
else
                    {
                        
*pDest++ = ch;
                    }
                    iLength 
--;
                }
                
*pDest = 0;
                getOriData()
->Length = getOriData()->Length - iFoundCount;
            }
            
return iFoundCount;
        }
        
//一组删除子串的函数
        ///删除子串
        /**
            这个函数指定的要删除的子串和要删除子串的次数
            @param [in] paramRemoveString 要删除的子串
            @param [in] paramMaxRemoveCount 要删除子串的最大删除次数,-1表示不限制次数
            @return XInt 实际删除的次数
         
*/
        XInt RemoveString(
const XStringBase<T> & paramRemoveString, XInt paramMaxRemoveCount)
        {
            
return RemoveString(0, paramRemoveString.c_str(), paramRemoveString.getLength(), paramMaxRemoveCount);
        }
        
///删除子串
        /**
            这个函数指定的要删除的子串和要删除子串的次数
            @param [in] paramStartPos 指定开始删除的位置
            @param [in] paramRemoveString 要删除的子串
            @param [in] paramMaxRemoveCount 要删除子串的最大删除次数,-1表示不限制次数
            @return XInt 实际删除的次数
         
*/
        XInt RemoveString(XInt paramStartPos, 
const XStringBase<T> & paramRemoveString, XInt paramMaxRemoveCount)
        {
            
return RemoveString(paramStartPos, paramRemoveString.c_str(), paramRemoveString.getLength(), paramMaxRemoveCount);
        }
        
///删除子串
        /**
            这个函数指定的要删除的子串和要删除子串的次数
            @param [in] paramRemoveString 要删除的子串
            @param [in] paramMaxRemoveCount 要删除子串的最大删除次数,-1表示不限制次数
            @return XInt 实际删除的次数
         
*/
        XInt RemoveString(
const T * paramRemoveString, XInt paramMaxRemoveCount)
        {
            
return RemoveString(0, paramRemoveString, string_utils::Length(paramRemoveString), paramMaxRemoveCount);
        }
        
///删除子串
        /**
            这个函数指定的要删除的子串和要删除子串的次数
            @param [in] paramStartPos 指定开始删除的位置
            @param [in] paramRemoveString 要删除的子串
            @param [in] paramMaxRemoveCount 要删除子串的最大删除次数,-1表示不限制次数
            @return XInt 实际删除的次数
         
*/
        XInt RemoveString(XInt paramStartPos, T 
* paramRemoveString, XInt paramMaxRemoveCount)
        {
            
return RemoveString(paramStartPos, paramRemoveString, string_utils::Length(paramRemoveString), paramMaxRemoveCount);
        }
        
///删除子串
        /**
            这个函数指定的要删除的子串
            @param [in] paramRemoveString 要删除的子串
            @return XInt 实际删除的次数
         
*/
        XInt RemoveString(
const XStringBase<T> & paramRemoveString)
        {
            
return RemoveString(0, paramRemoveString.c_str(), paramRemoveString.getLength(), -1);
        }
        
///删除子串
        /**
            这个函数指定的要删除的子串
            @param [in] paramStartPos 指定开始删除的位置
            @param [in] paramRemoveString 要删除的子串
            @return XInt 实际删除的次数
         
*/
        XInt RemoveString(XInt paramStartPos, 
const XStringBase<T> & paramRemoveString)
        {
            
return RemoveString(paramStartPos, paramRemoveString.c_str(), paramRemoveString.getLength(), -1);
        }
        
///删除子串
        /**
            这个函数指定的要删除的子串
            @param [in] paramRemoveString 要删除的子串
            @return XInt 实际删除的次数
         
*/
        XInt RemoveString(
const T * paramRemoveString)
        {
            
return RemoveString(0, paramRemoveString, string_utils::Length(paramRemoveString), -1);
        }
        
///删除子串
        /**
            这个函数指定的要删除的子串
            @param [in] paramStartPos 指定开始删除的位置
            @param [in] paramRemoveString 要删除的子串
            @return XInt 实际删除的次数
         
*/
        XInt RemoveString(XInt paramStartPos, T 
* paramRemoveString)
        {
            
return RemoveString(paramStartPos, paramRemoveString, string_utils::Length(paramRemoveString), -1);
        }
        
///删除指定的子串
        /**
            @param [in] paramStartPos 开始删除的下标
            @param [in] paramRemoveString 要删除的子串
            @param [in] paramRemoveStringLength 要删除子串的长度
            @param [in] paramMaxRemoveCount 要删除的次数,-1表示不限次数
            @return XInt 实际删除子串的次数
         
*/
        XInt RemoveString(XInt paramStartPos, 
const T * paramRemoveString, XInt paramRemoveStringLength, XInt paramMaxRemoveCount)
        {
            ZDH_ASSERT(paramRemoveString 
!= NULL);
            ZDH_ASSERT(paramRemoveStringLength 
== string_utils::Length(paramRemoveString));
            XInt iLocalLength 
= getLength();
            
if( paramStartPos < 0)
            {
                paramStartPos 
= 0;
            }
            
else if( paramStartPos >= iLocalLength ) 
            {
                
return 0;
            }

            XInt iFoundCount 
= 0;
            
if( paramRemoveStringLength > 0 && iLocalLength >= paramRemoveStringLength )
            {

                XInt iPos 
= Pos(paramStartPos, paramRemoveString);
                XChar 
* pDest = (XChar *)c_str();
                
const XChar * pSrc = c_str();

                
while(iPos >= 0 &&( paramMaxRemoveCount < 0|| (paramMaxRemoveCount > iFoundCount) ))
                {
                    
const XChar * pFound = c_str() + iPos;
                    iFoundCount 
++;

                    
while( pSrc < pFound )
                    {
                        
*pDest++ = *pSrc++;
                    }

                    pSrc 
= pFound + paramRemoveStringLength;
                    iPos 
= Pos(iPos + paramRemoveStringLength, paramRemoveString);
                }
                
if( iFoundCount > 0
                {
                    
const XChar * pLast = c_str() + iLocalLength;

                    
while(pSrc < pLast)
                    {
                        
*pDest ++ = *pSrc++;
                    }

                    
*pDest = 0;
                    getOriData()
->Length = iLocalLength - paramRemoveStringLength * iFoundCount;
                }
            }
            
return iFoundCount;
        }
        
///将当前字符串小写转换成大写
        void UpperCase() 
        {
            string_utils::UpperCase((T 
*)Data());
        }
        
///将字符串大写转换成小写
        void LowerCase()
        {
            string_utils::LowerCase((T 
*)Data());
        }
        
///将整数转换为16进制串
        /**
            @param [in] paramValue 要转换的值
            @param [in] paramHexWidth 16进制数字的宽度
            @param [in] paramHexStyle 16进制的样式
            @param [in] paramHexPrefix 是否要0x前缀
         
*/
        
void NumberToHex(XInt paramValue,XInt paramHexWidth = 1, T paramHexStyle = 'A'bool paramHexPrefix = true)
        {
            NumberToHex((XDWord)paramValue, paramHexWidth, paramHexStyle, paramHexPrefix);
        }
        
///将整数转换为16进制串
        /**
            @param [in] paramValue 要转换的值
            @param [in] paramHexWidth 16进制数字的宽度
            @param [in] paramHexStyle 16进制的样式
            @param [in] paramHexPrefix 是否要0x前缀
         
*/
        
void NumberToHex(XDWord paramValue,XInt paramHexWidth = 1, T paramHexStyle = 'A'bool paramHexPrefix = true)
        {
            
if( paramHexWidth > 8
            {
                ensureCapacity(paramHexWidth 
+ 4);
            }
            
else 
            {
                ensureCapacity(
12);
            }
            string_utils::DWordToHex(paramValue, (T 
*)Data(), paramHexWidth, paramHexStyle, paramHexPrefix);
        }
        
///将整数转换为16进制串
        /**
            @param [in] paramValue 要转换的值
            @param [in] paramHexWidth 16进制数字的宽度
            @param [in] paramHexStyle 16进制的样式
            @param [in] paramHexPrefix 是否要0x前缀
         
*/
        
void NumberToHex(XLong paramValue,XInt paramHexWidth = 1, T paramHexStyle = 'A'bool paramHexPrefix = true)
        {
            NumberToHex((XDDWord)paramValue, paramHexWidth, paramHexStyle, paramHexPrefix);
        }
        
///将整数转换为16进制串
        /**
            @param [in] paramValue 要转换的值
            @param [in] paramHexWidth 16进制数字的宽度
            @param [in] paramHexStyle 16进制的样式
            @param [in] paramHexPrefix 是否要0x前缀
         
*/
        
void NumberToHex(XDDWord paramValue,XInt paramHexWidth = 1, T paramHexStyle = 'A'bool paramHexPrefix = true)
        {
            
if( paramHexWidth > 16
            {
                ensureCapacity(paramHexWidth 
+ 4);
            }
            
else 
            {
                ensureCapacity(
20);
            }
            string_utils::DDWordToHex(paramValue, (T 
*)Data(), paramHexWidth, paramHexStyle, paramHexPrefix);
        }
    
protected:
        
///扩展容量
        /**
            注意:这个函数,并不会做安全检查
            @param [in] paramMinimumCapacity 指定的最小容量,这个容量是字符个数
         
*/
        
void expandCapacity(XInt paramMinimumCapacity);
        
///取实际字符串指针
        /**
            注意:这里不会做越界检查,
         
*/
        
const SStringStruct * getOriData() const  {    return ((const SStringStruct *)m_Data) - 1;    }
        
///取实际字符串指针
        /**
            注意:这里不会做越界检查
         
*/
        SStringStruct 
* getOriData() {    return ((SStringStruct *)m_Data) - 1;}
        
///复制字符串
        /**
            @param [in] paramSrc 源字符串地址
            @param [out] paramDest 目标串地址
            @param [in] paramCopyCharNumber 要复制的字符个数
         
*/
        
static void CopyData(const T * paramSrc, T * paramDest, XInt paramCopyCharNumber)
        {
            
//ZDH_ASSERT(paramCopyCharNumber > 0);
            XInt iCopyBytes = paramCopyCharNumber * sizeof(T);
            XInt iCopyCount 
= iCopyBytes / sizeof(XDDWord);
            XDDWord 
* pS = (XDDWord *)paramSrc;
            XDDWord 
* pD = (XDDWord *)paramDest;
            
for(XInt i = iCopyCount; i > 0; i--, pS ++, pD++ )
            {
                
*pD = *pS;
            }            
            XByte 
* pBS = (XByte *)pS;
            XByte 
* pBD = (XByte *)pD;
            
for(XInt i = iCopyBytes - iCopyCount * sizeof(XDDWord);i > 0; i--, pBS ++, pBD++ )
            {
                
*pBD = *pBS;
            }
            
*((T *)pBD) = 0;
        }

        
///查找子串是否存在
        /**
            @param [in] paramString 查找的字符串
            @param [in] paramSubString 被查找的子串
            @return T * 返回结果
                - NULL 表示未找到该子串
                - not NULL 表示找到了该子串,并返回该子串的地址
         
*/
        
static const T * FindString(const T * paramString, const T * paramSubString)
        {
            
if( isNULL(paramSubString) ) return paramString;
            
if( isNULL(paramString) ) return NULL;
            
const T * s = paramString;
            T c 
= *s;
            T c2 
= *paramSubString;
            
while( c )
            {
                
if( c == c2 ) //如果找到了第一个字符,那么开始找子串
                {
                    
const T * s1 = s;
                    
const T * s2 = paramSubString;
                    T t1 
= c;
                    T t2 
= c2;
                    
while( t1 && t2 && (!(t2 - t1)))
                    {
                        t1 
= *++s1;
                        t2 
= *++s2;
                    }
                    
if!t2 ) return s;
                }
                c 
= *++s;
            }
            
return NULL;
        }
    
private:
        T 
* m_Data;            ///<数据指针
    };
//     ///替换字符串
//     /**
//         @param [in] paramSrc 源字符串
//         @param [out] paramResult 目标存放字符串
//         @param [in] paramFindString 查询的内容
//         @param [in] paramReplaceString 被替换的内容
//         @return XInt 被替换的次数
// 
//      */
//     template<class T>
//     inline XInt ReplaceString(const T & paramSrc, T & paramResult, const T & paramFindString,const T & paramReplaceString)
//     {
//         const T * pSrc = &paramSrc;
//         T strTmp;
//         if( pSrc == &paramResult )
//         {
//             strTmp = paramSrc;
//             pSrc = &strTmp;
//         }
//         XInt iReplaceCount = 0;
//         T & strSource = &pSrc;
//         XInt iPos = strSource.Pos(0,paramFindString);
//         
//         XInt iLastPos = 0;
//         
//         while(iPos != -1)
//         {
//             
//         }
// 
//     };

    
///单字符字符串
    class XAnsiString : public XStringBase<XChar>
    {
    
public:
        typedef XStringBase
<XChar> Inherited;
    
public:
        
///默认构造函数
        XAnsiString(){}
        
///指定初始值的构造函数
        XAnsiString(const XChar * paramString)
            :Inherited(paramString)
        {}
        
///默认拷贝构造函数
        XAnsiString(const XAnsiString & paramString)
            :Inherited(paramString)
        {}
        
///指定初始字符构造函数
        XAnsiString(XChar paramChar)
            :Inherited(paramChar)
        {}
        
///指定8位无符号整数构造函数
        XAnsiString(const XByte & paramByte)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramByte,TempBuffer));
        }
        
///指定16位有符号整数构造函数
        XAnsiString(const XShort & paramNumber)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramNumber,TempBuffer));
        }
        
///指定16位无符号整数构造函数
        XAnsiString(const XWord & paramNumber)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramNumber,TempBuffer));
        }
        
///指定32位有符号整数构造函数
        XAnsiString(const XInt & paramNumber)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramNumber,TempBuffer));
        }
        
///指定32位无符号整数构造函数
        XAnsiString(const XDWord & paramNumber)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::DWordToStr(paramNumber,TempBuffer));
        }
        
///指定64位有符号整数构造函数
        XAnsiString(const XLong & paramNumber)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::LongToStr(paramNumber,TempBuffer));
        }
        
///指定64位无符号整数构造函数
        XAnsiString(const XDDWord & paramNumber)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::DDWordToStr(paramNumber,TempBuffer));
        }
        XAnsiString 
& operator = (const XChar * paramValue)
        {
            Assign(paramValue);
            
return *this;
        }
        
///指定字符赋值函数
        XAnsiString & operator = (const XChar & paramValue)
        {
            Assign(paramValue);
            
return *this;
        }
        
///指定8位无符号整数赋值函数
        XAnsiString & operator = (const XByte & paramValue)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定16位有符号整数赋值函数
        XAnsiString & operator = (const XShort & paramValue)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定16位无符号整数赋值函数
        XAnsiString & operator = (const XWord & paramValue)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定32位有符号整数赋值函数
        XAnsiString & operator = (const XInt & paramValue)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定32位无符号整数赋值函数
        XAnsiString & operator = (const XDWord & paramValue)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::DWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定64位有符号整数赋值函数
        XAnsiString & operator = (const XLong & paramValue)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::LongToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定64位无符号整数赋值函数
        XAnsiString & operator = (const XDDWord & paramValue)
        {
            XChar TempBuffer[
32];
            Assign(string_utils::DDWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定字符串赋值函数
        XAnsiString & operator = (const XAnsiString & paramValue)
        {
            
if&paramValue != this)
            {
                Assign(paramValue);
            }
            
return *this;
        }
        
///追加一个字符串
        XAnsiString & operator += (const XChar * paramValue)
        {
            AppendString(paramValue);
//,::strlen(paramValue));
            return *this;
        }
        
///追加一个字符
        XAnsiString & operator += (const XChar & paramValue)
        {
            AppendChar(paramValue);
            
return *this;
        }
        
///追加8位无符号整数
        XAnsiString & operator += (const XByte & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位有符号整数
        XAnsiString & operator += (const XShort & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位无符号整数
        XAnsiString & operator += (const XWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位有符号整数
        XAnsiString & operator += (const XInt & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位无符号整数
        XAnsiString & operator += (const XDWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位有符号整数
        XAnsiString & operator += (const XLong & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::LongToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位无符号整数
        XAnsiString & operator += (const XDDWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加一个字符串
        XAnsiString & operator += (const XAnsiString & paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///追加一个字符串
        XAnsiString & operator << (const XChar * paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///追加一个字符
        XAnsiString & operator << (const XChar & paramValue)
        {
            AppendChar(paramValue);
            
return *this;
        }
        
///追加8位无符号整数
        XAnsiString & operator << (const XByte & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位有符号整数
        XAnsiString & operator << (const XShort & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位无符号整数
        XAnsiString & operator << (const XWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位有符号整数
        XAnsiString & operator << (const XInt & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位无符号整数
        XAnsiString & operator << (const XDWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位有符号整数
        XAnsiString & operator << (const XLong & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::LongToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位无符号整数
        XAnsiString & operator << (const XDDWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加一个字符串
        XAnsiString & operator << (const XAnsiString & paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///追加一个字符串
        XAnsiString & operator , (const XChar * paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///追加一个字符
        XAnsiString & operator , (const XChar & paramValue)
        {
            AppendChar(paramValue);
            
return *this;
        }
        
///追加8位无符号整数
        XAnsiString & operator , (const XByte & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位有符号整数
        XAnsiString & operator , (const XShort & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位无符号整数
        XAnsiString & operator , (const XWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位有符号整数
        XAnsiString & operator , (const XInt & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位无符号整数
        XAnsiString & operator , (const XDWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位有符号整数
        XAnsiString & operator , (const XLong & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::LongToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位无符号整数
        XAnsiString & operator , (const XDDWord & paramValue)
        {
            XChar TempBuffer[
32];
            AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加一个字符串
        XAnsiString & operator , (const XAnsiString & paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///重载[]运算符
        XChar operator[](XInt paramIndex) const
        {
            
return at(paramIndex);
        }
        
///重载[]运算符
        XChar & operator[](XInt paramIndex)
        {
            
return at(paramIndex);
        }
        
///连接一个字符
        XAnsiString operator + (const XChar & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接8位无符整数
        XAnsiString operator + (const XByte & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接16位有符整数
        XAnsiString operator + (const XShort & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接16位无符整数
        XAnsiString operator + (const XWord & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接32位有符整数
        XAnsiString operator + (const XInt & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接32位无符整数
        XAnsiString operator + (const XDWord & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接64位有符整数
        XAnsiString operator + (const XLong & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接64位无符整数
        XAnsiString operator + (const XDDWord & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接一个字符串
        XAnsiString operator + (const XAnsiString & paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接一个字符串
        XAnsiString operator + (const XChar * paramValue) const
        {
            XAnsiString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }

        
//一组比较函数
        bool operator == (const XAnsiString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) == 0;
        }
        
bool operator != (const XAnsiString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) != 0;
        }
        
bool operator >= (const XAnsiString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) >= 0;
        }
        
bool operator <= (const XAnsiString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) <= 0;
        }
        
bool operator > (const XAnsiString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) > 0;
        }
        
bool operator < (const XAnsiString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) < 0;
        }

        
//一组比较函数
        bool operator == (const XChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) == 0;
        }
        
bool operator != (const XChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) != 0;
        }
        
bool operator >= (const XChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) >= 0;
        }
        
bool operator <= (const XChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) <= 0;
        }
        
bool operator > (const XChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) > 0;
        }
        
bool operator < (const XChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) < 0;
        }
        
///指定格式化生成字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XAnsiString & 返回当前字符串
         
*/
        XAnsiString
& sprintf(const XChar* paramFormat, // Returns *this
        {
            va_list argptr;
            va_start(argptr, paramFormat);
            vprintf(paramFormat,argptr);
            
return *this;
        }
        
///指定格式化生成字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XInt 返回格式化字符串的长度
         
*/
        XInt printf(
const XChar* paramFormat, // Returns formatted length
        {
            va_list argptr;
            va_start(argptr, paramFormat);
            
return vprintf(paramFormat,argptr);
        }
        
///指定格式化生成字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XInt 返回格式化字符串的长度
         
*/
        XInt vprintf(
const XChar* paramFormat, va_list paramList) // Returns formatted length
        {
            #ifdef CONFIG_VC
            XInt iLength 
= _vscprintf(paramFormat,paramList);
            
#else
            XInt iLength 
= snprintf(NULL,0,paramFormat,paramList);
            
#endif
            
if( iLength > 0)
            {
                ensureCapacity(iLength);
                vsprintf((XChar 
*)Data(),paramFormat,paramList);
                getOriData()
->Length = iLength;
            }
            
return iLength;
        }
        
///指定连接格式化生成的字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XAnsiString & 返回当前字符串
         
*/
        XAnsiString
& cat_sprintf(const char* paramFormat, // Returns *this
        {
            va_list argptr;
            va_start(argptr, paramFormat);
            cat_vprintf(paramFormat,argptr);
            
return *this;
        }
        
///指定连接格式化生成的字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XInt 返回格式化字符串的长度
         
*/
        XInt cat_printf(
const char* paramFormat, // Returns formatted length
        {
            va_list argptr;
            va_start(argptr, paramFormat);
            
return cat_vprintf(paramFormat,argptr);
        }
        
///指定连接格式化生成的字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XInt 返回格式化字符串的长度
         
*/
        XInt cat_vprintf(
const char* paramFormat, va_list paramList) // Returns formatted length
        {
            #ifdef CONFIG_VC
            XInt iLength 
= _vscprintf(paramFormat,paramList);
            
#else
            XInt iLength 
= snprintf(NULL,0,paramFormat,paramList);
            
#endif
            
if( iLength > 0)
            {
                XInt iLocalLength 
= getLength();
                ensureCapacity(iLength 
+ iLocalLength);
                vsprintf(((XChar 
*)Data()) + iLocalLength,paramFormat,paramList);
                getOriData()
->Length = iLength + iLocalLength;
            }
            
return iLength;
        }


        
///清空字符串左右两边空格字符
        XAnsiString Trim() const
        {
            XAnsiString strRet(
*this);
            
if( strRet.isNotEmpty() )
            {
                strRet.getOriData()
->Length = string_utils::Trim((XChar *)strRet.Data(),strRet.getLength());
            }
            
return strRet;
        }
        XAnsiString 
& Trim(XAnsiString & paramStore) const
        {
            paramStore 
= *this;
            
if( paramStore.isNotEmpty() )
            {
                paramStore.getOriData()
->Length = string_utils::Trim((XChar *)paramStore.Data(),paramStore.getLength());
            }
            
return paramStore;
        }
        
///清空字符串左边空格字符串
        XAnsiString TrimLeft() const
        {
            XAnsiString strRet(
*this);
            
if( strRet.isNotEmpty() )
            {
                strRet.getOriData()
->Length = string_utils::TrimLeft((XChar *)strRet.Data(),strRet.getLength());
            }
            
return strRet;
        }
        XAnsiString 
& TrimLeft(XAnsiString & paramStore) const
        {
            paramStore 
= *this;
            
if( paramStore.isNotEmpty() )
            {
                paramStore.getOriData()
->Length = string_utils::TrimLeft((XChar *)paramStore.Data(),paramStore.getLength());
            }
            
return paramStore;
        }
        
///清空字符串右边空格字符串
        XAnsiString TrimRight() const
        {
            XAnsiString strRet(
*this);
            
if( strRet.isNotEmpty() )
            {
                strRet.getOriData()
->Length = string_utils::TrimRight((XChar *)strRet.Data(),strRet.getLength());
            }
            
return strRet;
        }
        XAnsiString 
& TrimRight(XAnsiString & paramStore) const
        {
            paramStore 
= *this;
            
if( paramStore.isNotEmpty() )
            {
                paramStore.getOriData()
->Length = string_utils::TrimRight((XChar *)paramStore.Data(),paramStore.getLength());
            }
            
return paramStore;
        }
        
///取指定的子串
        XAnsiString & SubString(const XInt paramStartPos, const XInt paramSubLength, XAnsiString & paramStore ) const
        {
            XAnsiString 
& strRet = paramStore;
            XInt iLength 
= getLength();
            
if( paramStartPos >= 0 && paramSubLength > 0 && paramStartPos < iLength )
            {
                XInt iMaxLength 
= iLength - paramStartPos;
                
if( iMaxLength > paramSubLength) iMaxLength = paramSubLength;
                strRet.ensureCapacity( iMaxLength );
                
const XChar * pSrc = c_str() + paramStartPos;
                
while( iMaxLength > 0)
                {
                    strRet 
+= *pSrc ++;
                    iMaxLength 
--;
                }
            }
            
return paramStore;
        }
        
///取指定的子串
        /**
            @param [in] paramStartPos 指定的位置
            @param [in] paramSubLength 子串的长度
            @return XAnsiString 取得的子串
         
*/
        XAnsiString SubString(
const XInt paramStartPos, const XInt paramSubLength) const
        {
            XAnsiString strRet;
            SubString(paramStartPos,paramSubLength,strRet);
            
return strRet;
        }
        
///取空串
        static const XAnsiString & EmptyString() 
        {
            
static XAnsiString sEmptyString;
            
return sEmptyString;
        }
    };
    
//---------------------------------------------------------------------------------------------------
    ///双字符字符串
    class XWideString : public XStringBase<XWideChar>
    {
    
public:
        typedef XStringBase
<XWideChar> Inherited;
    
public:
        
///默认构造函数
        XWideString(){}
        
///指定初始值的构造函数
        XWideString(const XWideChar * paramString)
            :Inherited(paramString)
        {}
        
///默认拷贝构造函数
        XWideString(const XWideString & paramString)
            :Inherited(paramString)
        {}
        
///指定初始字符构造函数
        XWideString(XWideChar paramChar)
            :Inherited(paramChar)
        {}
        
///指定8位无符号整数构造函数
        XWideString(const XByte & paramByte)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramByte,TempBuffer));
        }
        
///指定16位有符号整数构造函数
        XWideString(const XShort & paramNumber)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramNumber,TempBuffer));
        }
        
///指定16位无符号整数构造函数
        XWideString(const XWord & paramNumber)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramNumber,TempBuffer));
        }
        
///指定32位有符号整数构造函数
        XWideString(const XInt & paramNumber)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramNumber,TempBuffer));
        }
        
///指定32位无符号整数构造函数
        XWideString(const XDWord & paramNumber)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::DWordToStr(paramNumber,TempBuffer));
        }
        
///指定64位有符号整数构造函数
        XWideString(const XLong & paramNumber)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::LongToStr(paramNumber,TempBuffer));
        }
        
///指定64位无符号整数构造函数
        XWideString(const XDDWord & paramNumber)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::DDWordToStr(paramNumber,TempBuffer));
        }
        XWideString 
& operator = (const XWideChar * paramValue)
        {
            Assign(paramValue);
            
return *this;
        }
        
///指定字符赋值函数
        XWideString & operator = (const XWideChar & paramValue)
        {
            Assign(paramValue);
            
return *this;
        }
        
///指定8位无符号整数赋值函数
        XWideString & operator = (const XByte & paramValue)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定16位有符号整数赋值函数
        XWideString & operator = (const XShort & paramValue)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定16位无符号整数赋值函数
        XWideString & operator = (const XWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定32位有符号整数赋值函数
        XWideString & operator = (const XInt & paramValue)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定32位无符号整数赋值函数
        XWideString & operator = (const XDWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::DWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定64位有符号整数赋值函数
        XWideString & operator = (const XLong & paramValue)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::LongToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定64位无符号整数赋值函数
        XWideString & operator = (const XDDWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            Assign(string_utils::DDWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///指定字符串赋值函数
        XWideString & operator = (const XWideString & paramValue)
        {
            
if&paramValue != this)
            {
                Assign(paramValue);
            }
            
return *this;
        }
        
///追加一个字符串
        XWideString & operator += (const XWideChar * paramValue)
        {
            AppendString(paramValue);
//,::strlen(paramValue));
            return *this;
        }
        
///追加一个字符
        XWideString & operator += (const XWideChar & paramValue)
        {
            AppendChar(paramValue);
            
return *this;
        }
        
///追加8位无符号整数
        XWideString & operator += (const XByte & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位有符号整数
        XWideString & operator += (const XShort & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位无符号整数
        XWideString & operator += (const XWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位有符号整数
        XWideString & operator += (const XInt & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位无符号整数
        XWideString & operator += (const XDWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位有符号整数
        XWideString & operator += (const XLong & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::LongToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位无符号整数
        XWideString & operator += (const XDDWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加一个字符串
        XWideString & operator += (const XWideString & paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///追加一个字符串
        XWideString & operator << (const XWideChar * paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///追加一个字符
        XWideString & operator << (const XWideChar & paramValue)
        {
            AppendChar(paramValue);
            
return *this;
        }
        
///追加8位无符号整数
        XWideString & operator << (const XByte & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位有符号整数
        XWideString & operator << (const XShort & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位无符号整数
        XWideString & operator << (const XWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位有符号整数
        XWideString & operator << (const XInt & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位无符号整数
        XWideString & operator << (const XDWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位有符号整数
        XWideString & operator << (const XLong & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::LongToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位无符号整数
        XWideString & operator << (const XDDWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加一个字符串
        XWideString & operator << (const XWideString & paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///追加一个字符串
        XWideString & operator , (const XWideChar * paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///追加一个字符
        XWideString & operator , (const XWideChar & paramValue)
        {
            AppendChar(paramValue);
            
return *this;
        }
        
///追加8位无符号整数
        XWideString & operator , (const XByte & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位有符号整数
        XWideString & operator , (const XShort & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加16位无符号整数
        XWideString & operator , (const XWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位有符号整数
        XWideString & operator , (const XInt & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::IntToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加32位无符号整数
        XWideString & operator , (const XDWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位有符号整数
        XWideString & operator , (const XLong & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::LongToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加64位无符号整数
        XWideString & operator , (const XDDWord & paramValue)
        {
            XWideChar TempBuffer[
32];
            AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
            
return *this;
        }
        
///追加一个字符串
        XWideString & operator , (const XWideString & paramValue)
        {
            AppendString(paramValue);
            
return *this;
        }
        
///重载[]运算符
        XWideChar operator[](XInt paramIndex) const
        {
            
return at(paramIndex);
        }
        
///重载[]运算符
        XWideChar & operator[](XInt paramIndex)
        {
            
return at(paramIndex);
        }
        
///连接一个字符
        XWideString operator + (const XWideChar & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接8位无符整数
        XWideString operator + (const XByte & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接16位有符整数
        XWideString operator + (const XShort & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接16位无符整数
        XWideString operator + (const XWord & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接32位有符整数
        XWideString operator + (const XInt & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接32位无符整数
        XWideString operator + (const XDWord & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接64位有符整数
        XWideString operator + (const XLong & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接64位无符整数
        XWideString operator + (const XDDWord & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接一个字符串
        XWideString operator + (const XWideString & paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }
        
///连接一个字符串
        XWideString operator + (const XWideChar * paramValue) const
        {
            XWideString strRet(
*this);
            strRet 
+= paramValue;
            
return strRet;
        }

        
//一组比较函数
        bool operator == (const XWideString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) == 0;
        }
        
bool operator != (const XWideString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) != 0;
        }
        
bool operator >= (const XWideString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) >= 0;
        }
        
bool operator <= (const XWideString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) <= 0;
        }
        
bool operator > (const XWideString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) > 0;
        }
        
bool operator < (const XWideString & paramR) const
        {
            
return string_utils::Compare(c_str(),paramR.c_str()) < 0;
        }

        
//一组比较函数
        bool operator == (const XWideChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) == 0;
        }
        
bool operator != (const XWideChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) != 0;
        }
        
bool operator >= (const XWideChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) >= 0;
        }
        
bool operator <= (const XWideChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) <= 0;
        }
        
bool operator > (const XWideChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) > 0;
        }
        
bool operator < (const XWideChar * paramR) const
        {
            
return string_utils::Compare(c_str(),paramR) < 0;
        }
        
///指定格式化生成字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XWideString & 返回当前字符串
         
*/
        XWideString
& sprintf(const XWideChar* paramFormat, // Returns *this
        {
            va_list argptr;
            va_start(argptr, paramFormat);
            vprintf(paramFormat,argptr);
            
return *this;
        }
        
///指定格式化生成字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XInt 返回格式化字符串的长度
         
*/
        XInt printf(
const XWideChar* paramFormat, // Returns formatted length
        {
            va_list argptr;
            va_start(argptr, paramFormat);
            
return vprintf(paramFormat,argptr);
        }
        
///指定格式化生成字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XInt 返回格式化字符串的长度
         
*/
        XInt vprintf(
const XWideChar* paramFormat, va_list paramList) // Returns formatted length
        {
            #ifdef CONFIG_VC
            XInt iLength 
= _vscwprintf(paramFormat,paramList);
            
#else
            XInt iLength 
= snwprintf(NULL,0,paramFormat,paramList);
            
#endif
            
if( iLength > 0)
            {
                ensureCapacity(iLength);
#ifdef CONFIG_VC
                vswprintf_s((XWideChar 
*)Data(),iLength+1,paramFormat,paramList);
#else
                vswprintf((XWideChar 
*)Data(),paramFormat,paramList);
#endif
                getOriData()
->Length = iLength;
            }
            
return iLength;
        }
        
///指定连接格式化生成的字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XWideString & 返回当前字符串
         
*/
        XWideString
& cat_sprintf(const XWideChar* paramFormat, // Returns *this
        {
            va_list argptr;
            va_start(argptr, paramFormat);
            cat_vprintf(paramFormat,argptr);
            
return *this;
        }
        
///指定连接格式化生成的字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XInt 返回格式化字符串的长度
         
*/
        XInt cat_printf(
const XWideChar* paramFormat, // Returns formatted length
        {
            va_list argptr;
            va_start(argptr, paramFormat);
            
return cat_vprintf(paramFormat,argptr);
        }
        
///指定连接格式化生成的字符串
        /**
            @param [in] 格式化串,参考标准C的格式化串
            @return XInt 返回格式化字符串的长度
         
*/
        XInt cat_vprintf(
const XWideChar* paramFormat, va_list paramList) // Returns formatted length
        {
            #ifdef CONFIG_VC
            XInt iLength 
= _vscwprintf(paramFormat,paramList);
            
#else
            XInt iLength 
= snwprintf(NULL,0,paramFormat,paramList);
            
#endif
            
if( iLength > 0)
            {
                XInt iLocalLength 
= getLength();
                ensureCapacity(iLength 
+ iLocalLength);
#ifdef CONFIG_VC
                vswprintf_s((XWideChar 
*)Data() + iLocalLength,iLength+1,paramFormat,paramList);
#else
                vswprintf(((XWideChar 
*)Data()) + iLocalLength,paramFormat,paramList);
#endif
                getOriData()
->Length = iLength + iLocalLength;
            }
            
return iLength;
        }


        
///清空字符串左右两边空格字符
        XWideString Trim() const
        {
            XWideString strRet(
*this);
            
if( strRet.isNotEmpty() )
            {
                strRet.getOriData()
->Length = string_utils::Trim((XWideChar *)strRet.Data(),strRet.getLength());
            }
            
return strRet;
        }
        XWideString 
& Trim(XWideString & paramStore) const
        {
            paramStore 
= *this;
            
if( paramStore.isNotEmpty() )
            {
                paramStore.getOriData()
->Length = string_utils::Trim((XWideChar *)paramStore.Data(),paramStore.getLength());
            }
            
return paramStore;
        }
        
///清空字符串左边空格字符串
        XWideString TrimLeft() const
        {
            XWideString strRet(
*this);
            
if( strRet.isNotEmpty() )
            {
                strRet.getOriData()
->Length = string_utils::TrimLeft((XWideChar *)strRet.Data(),strRet.getLength());
            }
            
return strRet;
        }
        XWideString 
& TrimLeft(XWideString & paramStore) const
        {
            paramStore 
= *this;
            
if( paramStore.isNotEmpty() )
            {
                paramStore.getOriData()
->Length = string_utils::TrimLeft((XWideChar *)paramStore.Data(),paramStore.getLength());
            }
            
return paramStore;
        }
        
///清空字符串右边空格字符串
        XWideString TrimRight() const
        {
            XWideString strRet(
*this);
            
if( strRet.isNotEmpty() )
            {
                strRet.getOriData()
->Length = string_utils::TrimRight((XWideChar *)strRet.Data(),strRet.getLength());
            }
            
return strRet;
        }
        XWideString 
& TrimRight(XWideString & paramStore) const
        {
            paramStore 
= *this;
            
if( paramStore.isNotEmpty() )
            {
                paramStore.getOriData()
->Length = string_utils::TrimRight((XWideChar *)paramStore.Data(),paramStore.getLength());
            }
            
return paramStore;
        }
        
///取指定的子串
        XWideString & SubString(const XInt paramStartPos, const XInt paramSubLength, XWideString & paramStore ) const
        {
            XWideString 
& strRet = paramStore;
            XInt iLength 
= getLength();
            
if( paramStartPos >= 0 && paramSubLength > 0 && paramStartPos < iLength )
            {
                XInt iMaxLength 
= iLength - paramStartPos;
                
if( iMaxLength > paramSubLength) iMaxLength = paramSubLength;
                strRet.ensureCapacity( iMaxLength );
                
const XWideChar * pSrc = c_str() + paramStartPos;
                
while( iMaxLength > 0)
                {
                    strRet 
+= *pSrc ++;
                    iMaxLength 
--;
                }
            }
            
return paramStore;
        }
        
///取指定的子串
        /**
            @param [in] paramStartPos 指定的位置
            @param [in] paramSubLength 子串的长度
            @return XWideString 取得的子串
         
*/
        XWideString SubString(
const XInt paramStartPos, const XInt paramSubLength) const
        {
            XWideString strRet;
            SubString(paramStartPos,paramSubLength,strRet);
            
return strRet;
        }
        
///取空串
        static const XWideString & EmptyString() 
        {
            
static XWideString sEmptyString;
            
return sEmptyString;
        }
    };
    
//---------------------------------------------------------------------------------------------------
    ///异常类基类
    class XException
    {
    
public:
        
///默认构造函数
        XException()
            :m_HelpContext(
0)
        {}
        
///指定异常信息的构造函数
        /**
            @param [in] paramMessage 异常信息
            @param [in] paramHelpContext 帮助信息ID
         
*/
        XException(
const XAnsiString & paramMessage, XInt paramHelpContext = 0)
            :m_Message(paramMessage),
             m_HelpContext(paramHelpContext)
        {}
        
///指定异常信息的构造函数
        /**
            @param [in] paramMessage 异常信息
            @param [in] paramHelpContext 帮助信息ID
         
*/
        XException(
const XChar* paramMessage, XInt paramHelpContext = 0)
            :m_Message(paramMessage),
            m_HelpContext(paramHelpContext)
        {}
        
///析构函数
        virtual ~XException()
        {}
        
///取异常信息
        const XAnsiString getMessage() const
        {
            
return m_Message;
        }
        
///设置异常信息
        void setMessage(const XChar * paramMessage)        
        {
            m_Message 
= paramMessage;
        }
        
///设置异常信息
        void setMessage(const XAnsiString & paramMessage)
        {
            m_Message 
= paramMessage;
        }
        
///取帮助信息ID
        XInt getHelpContext() const
        {
            
return m_HelpContext;
        }
        
///设置帮助信息ID
        void setHelpContext(XInt paramHelpContext)
        {
            m_HelpContext 
= paramHelpContext;
        }
        
///转换成字符串指针
        operator const XChar *() const
        {
            
return m_Message.c_str();
        }
    
private:
        XAnsiString m_Message;    
///<异常信息
        XInt m_HelpContext;        ///<帮助信息ID
    };

    
#define MESSAGE_OUT_OF_MEMORY "out of memory"
    
#define MESSAGE_NOT_EXISTS "not exists object!"
    
#define MESSAGE_IS_ZERO "is zero"
    
#define MESSAGE_LESS_THAN_ZERO "less than zero"
    
#define MESSAGE_CONVERT_FAIL "Type convert fail"
    
#define MESSAGE_GREATER_THAN_ZERO "greater than zero"
    
#define MESSAGE_OUT_OF_RANGE "out of range:index=%d,length=%d"

    
///内存溢出异常
    class XEOutOfMemory : public XException
    {
    
public:
        
///默认构造函数
        XEOutOfMemory()
            :XException(MESSAGE_OUT_OF_MEMORY)
        {}
        
///指定异常信息的构造函数
        /**
            @param [in] paramMessage 异常信息
            @param [in] paramHelpContext 帮助信息ID
         
*/
        XEOutOfMemory(
const XAnsiString & paramMessage, XInt paramHelpContext = 0)
            :XException(paramMessage,paramHelpContext)
        {}
        
///指定异常信息的构造函数
        /**
            @param [in] paramMessage 异常信息
            @param [in] paramHelpContext 帮助信息ID
         
*/
        XEOutOfMemory(
const XChar* paramMessage, XInt paramHelpContext = 0)
            :XException(paramMessage,paramHelpContext)
        {}
        
///析构函数
        ~XEOutOfMemory()
        {
        }
    };
    
//---------------------------------------------------------------------
    class XEConvert : public XException
    {
    
public:
        
///默认构造函数
        XEConvert()
            :XException(MESSAGE_CONVERT_FAIL)
        {}
        
///指定异常信息的构造函数
        /**
            @param [in] paramMessage 异常信息
            @param [in] paramHelpContext 帮助信息ID
         
*/
        XEConvert(
const XAnsiString & paramMessage, XInt paramHelpContext = 0)
            :XException(paramMessage,paramHelpContext)
        {}
        
///指定异常信息的构造函数
        /**
            @param [in] paramMessage 异常信息
            @param [in] paramHelpContext 帮助信息ID
         
*/
        XEConvert(
const XChar* paramMessage, XInt paramHelpContext = 0)
            :XException(paramMessage,paramHelpContext)
        {}
        
///析构函数
        ~XEConvert()
        {
        }
    };


    
///数组越界异常
    class XEOutOfRange : public XException
    {
    
public:
        
///数组越界异常构造函数
        /**
            @param [in] paramIndex 越界的下标值
            @param [in] aLength 被越界的数组的长度
        
*/
        XEOutOfRange(XInt paramIndex 
= 0,XInt aLength = 0)
            :m_Index(paramIndex),m_Length(aLength)
        {
            MakeMsg();
        }
        
///析构函数
        ~XEOutOfRange(){}
        
///设置越界信息
        /**
            @param [in] paramIndex 越界的下标值
            @param [in] aLength 被越界的数组的长度
        
*/
        
void setInfo(XInt paramIndex,XInt aLength)
        {
            m_Index 
= paramIndex;
            m_Length 
= aLength;
            MakeMsg();
        }
        
///取越界的下标值
        /**
            @return 返回越界的下标值
         
*/
        XInt getIndex() 
const { return m_Index; }
        
///取被越界的数组的长度
        /**
            @return 返回被越界的长度
         
*/
        XInt getLength() 
const { return m_Length; }
    
protected:
        
///生成异常信息
        void MakeMsg()
        {
            XAnsiString strMsg;
            strMsg.printf(MESSAGE_OUT_OF_RANGE,m_Index,m_Length);
            setMessage(strMsg);
        }
    
private:
        XInt m_Index;  
///<越界的下标
        XInt m_Length; ///<被越界的数组的下标
    };
    
///值为零异常类
    class XEIsZero : public XException
    {
    
public:
        XEIsZero()
            :XException(MESSAGE_IS_ZERO)
        {}
    };
    
///值小于零异常类
    class XELessThanZero : public XException
    {
    
public:
        XELessThanZero()
            :XException(MESSAGE_LESS_THAN_ZERO)
        {}
    };
    
///值大于零异常类
    class XEGreatherThanZero : public XException
    {
    
public:
        XEGreatherThanZero()
            :XException(MESSAGE_GREATER_THAN_ZERO)
        {}
    };
    
///不存在异常类
    class XENotExists : public XException
    {
    
public:
        XENotExists()
            :XException(MESSAGE_NOT_EXISTS)
        {}
    };


    
///取指定下标的字符
    template<class T,class Alloctor>
    T XStringBase
<T,Alloctor>::at(XInt paramIndex) const ZDH_THROW(XEOutOfRange)
        ZDH_THROW(XEOutOfRange)
    {
        
if!CheckIndex(paramIndex) ) 
        {
            
throw XEOutOfRange(paramIndex,getLength());
        }
        
return *(((T *)m_Data) + paramIndex);
    }
    
//---------------------------------------------------------------------
    ///取指定下标的字符引用
    template<class T,class Alloctor>
    T 
& XStringBase<T,Alloctor>::at(XInt paramIndex)
        ZDH_THROW(XEOutOfRange)
    {
        
if!CheckIndex(paramIndex) ) 
        {
            
throw XEOutOfRange(paramIndex,getLength());
        }
        
return *(((T *)m_Data) + paramIndex);
    }
    
///扩展容量
    /**
        注意:这个函数,并不会做安全检查
        @param [in] paramMinimumCapacity 指定的最小容量,这个容量是字符个数
    
*/
    template
<class T,class Alloctor>
    
void XStringBase<T,Alloctor>::expandCapacity(XInt paramMinimumCapacity)
        ZDH_THROW(XEOutOfMemory)
    {
        
//ZDH_ASSERT(paramMinimumCapacity>0);
        XInt iNowCapacity = getCapacity();
        
if( iNowCapacity < paramMinimumCapacity)    
        {
            XInt iNewCapacity 
= paramMinimumCapacity * CHAR_SIZE + HEAD_SIZE; //取得实际所需的字节数
            iNowCapacity *= 2;
            
if( iNewCapacity < iNowCapacity) iNewCapacity = iNowCapacity;
            XInt iMod 
= iNewCapacity % STRING_BLOCK_SIZE;
            
//确保申请的内存为指定大小的倍数
            if( iMod > 0 )
            {
                iNewCapacity 
+= (STRING_BLOCK_SIZE - iMod);
            }
            SStringStruct 
* pData = (SStringStruct *)Alloctor::Alloc(iNewCapacity);
            
//检查内存是否溢出
            if( pData == NULL )
            {
                
throw XEOutOfMemory();
            }
            
//设置基本属性
            pData->Capacity = (iNewCapacity - HEAD_SIZE) / CHAR_SIZE;
            pData
->Length = getLength();
            
if( pData->Length > 0 ) //复制数据
            {
                CopyData( (T 
*)m_Data, (T *)(pData + 1), getLength() );
            }
            
else
            {
                
*((T *)(pData + 1)) = 0;
            }
            
//释放原来的
            if( m_Data != NULL )
            {
                Alloctor::Free(getOriData());
            }
            
//开始替换
            m_Data = (T *)(pData+1);
        }
    }

    
//-----------------------------------------------------------------------------
    ///将字符串转换成32位有符号整数
    /**
        转换失败,将抛出XEConvert异常
     
*/
    template
<class T,class Alloctor>
    XInt XStringBase
<T,Alloctor>::ToInt() const
        ZDH_THROW(XEConvert)
    {
        XInt iRet;
        
if!string_utils::TryStringToInt(c_str(),iRet))
        {
            
throw XEConvert();
        }
        
return iRet;
    }
    
///将字符串转换成32位无符号整数
    /**
        转换失败,将抛出XEConvert异常
     
*/
    template
<class T,class Alloctor>
    XDWord XStringBase
<T,Alloctor>::ToDWord() const
        ZDH_THROW(XEConvert)
    {
        XDWord dwRet;
        
if!string_utils::TryStringToDWord(c_str(),dwRet))
        {
            
throw XEConvert();
        }
        
return dwRet;
    }
    
///将字符串转换成64位有符号整数
    /**
        转换失败,将抛出XEConvert异常
     
*/
    template
<class T,class Alloctor>
    XLong XStringBase
<T,Alloctor>::ToLong() const
        ZDH_THROW(XEConvert)
    {
        XLong lngRet;
        
if!string_utils::TryStringToLong(c_str(),lngRet))
        {
            
throw XEConvert();
        }
        
return lngRet;
    }
    
///将字符串转换成64位无符号整数
    /**
        转换失败,将抛出XEConvert异常
     
*/
    template
<class T,class Alloctor>
    XDDWord XStringBase
<T,Alloctor>::ToDDWord() const
        ZDH_THROW(XEConvert)
    {
        XDDWord ddwRet;
        
if!string_utils::TryStringToDDWord(c_str(),ddwRet))
        {
            
throw XEConvert();
        }
        
return ddwRet;
    }
    
///重载ostream的<<运算符
    inline std::ostream & operator << (std::ostream & paramOutStream, const XAnsiString & paramStr)
    {
        return paramOutStream << paramStr.c_str();
    }
}
#endif /* X_STRING_H_ */


posted on 2010-10-25 14:50 冬瓜 阅读(3157) 评论(6)  编辑 收藏 引用 所属分类: 原创

Feedback

# re: 一个纯C++字符串的简陋实现 2010-10-25 15:36 孔雀
我认为楼主的文章中可以简要介绍一下你的这个类的设计。
代码可以作为附件部分,这样直接贴代码太长了。
谢谢楼主的分享。  回复  更多评论
  

# re: 一个纯C++字符串的简陋实现 2010-10-25 16:02 陈梓瀚(vczh)
如今的潮流都是只读字符串哈,创建出来之后就不给改了。  回复  更多评论
  

# re: 一个纯C++字符串的简陋实现 2010-10-25 16:35 溪流
哇,好长的代码。路过支持~  回复  更多评论
  

# re: 一个纯C++字符串的简陋实现 2010-10-25 16:39 冬瓜
等C++0x出来后,使用右值引用,就可以搞一个只读的字符串了@陈梓瀚(vczh)
  回复  更多评论
  

# re: 一个纯C++字符串的简陋实现 2010-10-25 16:41 冬瓜
还没有试过附件,下次试一下@孔雀
  回复  更多评论
  

# re: 一个纯C++字符串的简陋实现 2010-10-25 21:28 陈梓瀚(vczh)
@冬瓜
VS2010和G++都已经出来了  回复  更多评论
  


只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理