stl下string 一些类似MFC中CString的函数

class cstr
{
public:
    static void to_lower(char *str)
    {
        int   i = 0;
        while(str[i] != '\0')
        {
            if((str[i] >= 'A') && (str[i] <= 'Z'))
            {
                str[i] += 32;
            }
            ++i;
        }
    }

    static void to_upper(char *str)
    {
        int  i = 0;
        while(str[i] != '\0')
        {
            if((str[i] >= 'a') && (str[i] <= 'z'))
            {
                str[i] -= 32;
            }
            ++i;
        }
    }
    static void to_upper(std::string& str)
    {
        for (std::string::iterator it=str.begin(); it!=str.end(); ++it)        
        {
            if((*it >= 'a') && (*it <= 'z'))
            {
                *it -= 32;
            }            
        }
    }
    static void to_lower(std::string& str)
    {
        for (std::string::iterator it=str.begin(); it!=str.end(); ++it)        
        {
            if((*it >= 'A') && (*it <= 'Z'))
            {
                *it += 32;
            }            
        }
    }
/*
    static std::string to_upper(char *str)
    {
        int  i = 0;
        while(str[i] != '\0')
        {
            if((str[i] >= 'a') && (str[i] <= 'z'))
            {
                str[i] -= 32;
            }
            ++i;
        }
        return str;
    }
*/
    //字符串格式化函数
    static std::string format(const char *fmt, ...)
    {
        if (NULL == fmt)
        {
            return "";
        }
        std::string strResult = "";
        va_list marker = NULL;
        va_start(marker, fmt);                                //初始化变量参数
        size_t nLength = 1024*8+1;                            //获取格式化字符串长度
        std::vector<char> vBuffer(nLength, '\0');            //创建用于存储格式化字符串的字符数组
        MARK:int nWritten = _vsnprintf(&vBuffer[0], vBuffer.size(), fmt, marker);
        //当nwritten不小于0时返回的格式化到vbuffer中的数据长度,当小于0时说明出错,等于-1时说明长度不够,此时将重新分配空间,然后再做格式化
        if (nWritten >= 0)
        {
            strResult = &vBuffer[0];
        }
        //vbuffer长度不够,扩展nlength/2的长度
        else if (-1 == nWritten)
        {
            vBuffer.erase(vBuffer.begin(), vBuffer.end());
            nLength += nLength;
            vBuffer.resize(nLength, '\0');
            //最多分配1G的空间,超过1G将不再处理
            if (nLength < 1024*1024*1024)
            {
                goto MARK;
            }
        }
        va_end(marker);                                    //重置变量参数
        return strResult;
    }

    //字符串格式化函数
    static std::string format_s(size_t maxsize, const char *fmt, ...)
    {
        if (NULL == fmt)
        {
            return "";
        }
        std::string strResult = "";
        va_list marker = NULL;
        va_start(marker, fmt);                                //初始化变量参数
        size_t nLength = maxsize+1;                            //获取格式化字符串长度
        std::vector<char> vBuffer(nLength, '\0');            //创建用于存储格式化字符串的字符数组
        int nWritten = _vsnprintf(&vBuffer[0], vBuffer.size(), fmt, marker);
        //当nwritten不小于0时返回的格式化到vbuffer中的数据长度,当小于0时说明出错,此时返回空字符串
        if (nWritten > 0)
        {
            strResult = &vBuffer[0];
        }
        va_end(marker);                                    //重置变量参数
        return strResult;
    }

    static std::string left(const std::string& str, int nCount)
    {
        std::string s = str;
        int nSize = s.size();
        nCount<0?nCount=0:nCount;
        nCount>nSize?nCount=nSize:nCount;
        if (0 == nCount && 0 == nSize)
        {
            s = "";
        }
        else
        {
            s.erase(MIN2(nCount, nSize), nSize);
        }
        return s;
    }
    static std::string right(const std::string& str, int nCount)
    {
        std::string s = str;
        nCount<0?nCount=0:nCount;
        int nSize = s.size();
        int nLen  = nSize-nCount;
        if (nLen > 0)
        {
            s.erase(0, nLen);
        }
        return s;
    }
    static void replace(std::string& str, const char* szOld, const char* szNew)
    {
        if (NULL != szNew && NULL != szOld)
        {
            int nOldLen = strlen(szOld);
            int nNewLen = strlen(szNew);
            bool bEqual = ((nNewLen == nOldLen) && 0 == memcmp(szOld, szNew, nOldLen));
            //szOld不为空字符串且szOld和szNew不相同
            if (nOldLen > 0 && !bEqual)
            {
                size_t found = str.find(szOld);
                while (found != std::string::npos)
                {
                    str.replace(found, nOldLen, szNew);
                    found += nNewLen;
                    found = str.find(szOld, found);
                }
            }
        }
    }
    //去右空格
    static void trimright(std::string& str, const char* szTargets=NULL)
    {
        int nLen = str.size();
        int nTargetsLen = 0;
        //默认只去空格
        if (NULL == szTargets || (0 == strlen(szTargets)))
        {
            if (nLen > 0)
            {
                while (nLen > 0)
                {
                    if (str[nLen - 1] != 32)
                    {
                        break;
                    }
                    else
                    {
                        --nLen;
                        str.erase(nLen, 1);
                    }
                }
            }
        }
        else
        {
            nTargetsLen = strlen(szTargets);
            if (nLen > 0)
            {
                int i = 0;
                while (nLen > 0)
                {
                    if (str[nLen - 1] != szTargets[nTargetsLen - i - 1])
                    {
                        break;
                    }
                    else
                    {
                        ++i;
                        --nLen;
                    }
                    if (i == nTargetsLen)
                    {
                        str.erase(nLen, nTargetsLen);
                        i = 0;
                        nLen = str.size();
                    }
                }
            }
        }
    }
    //去左空格
    static void trimleft(std::string& str, const char* szTargets=NULL)
    {
        if (!szTargets || '\0'==szTargets[0] ||  '\0'==szTargets[1])
        {
            const char ch =  (!szTargets || '\0'==szTargets[0])?' ':szTargets[0];
            std::string::iterator it;
            for (it=str.begin(); it!=str.end(); ++it)
            {
                if (ch != *it)
                    break;
            }
            if (it != str.begin())
            {
                str.erase(str.begin(), it);
            }
        }
        else
        {
            const size_t nLen = strlen(szTargets);
            const size_t nStrLen = str.size();
            size_t nPos = 0;
            while ((nPos + nLen) <= nStrLen)
            {
                if (0 != memcmp(str.data()+nPos, szTargets, nLen))
                {
                    break;
                }
                nPos += nLen;
            }
            if (nPos > 0)
            {
                str.erase(0, nPos);
            }
        }
    }
};