string通用函数

这篇博文一个月前就想写了，但是拖到现在才有时间。
起因是要做一个公司的项目，这个项目是用MFC写的，其实底层实现大多数都是用的标准库，但是让我比较尴尬的是我不会MFC,于是就想把界面和底层剥离，用QT来设计界面。
别的还好说，最蛋疼的就是这个项目里用大量的CString变量以及相关函数，没办法我就替换这些函数，这就是背景，废话少说，直接上代码：

//声明
namespace CStirng2String
{
    //转大写   
    void strupper(string& str);                 

    //转小写   
    void strlower(string& str);

    //从最高位起去除空格，直至第一个非空格为止                  
    void TrimRight(string& str);

    //从最高位起去除指定字符串中的任意元素，直至第一个非子元素为止
    void TrimRight(string& str, const char* c);  

    //从最低位起去除空格，直至第一个非空格为止                  
    void TrimLeft(string& str);                 

    //从最高位起去除指定字符串中的任意元素，直至第一个非子元素为止
    void TrimLeft(string& str, const char* c);

    //去掉字符串里某个字符，注意，是都去掉    
    int DeleteChar(string& str,char ch = ' ');      

    //字符串以某段开头
    bool StartWith(const string& str,const string& strStart);       

    //字符串以某段结尾
    bool EndWith(const string& str,const string& strEnd);   

    //字符串替换     
    void replace_all(string& str, string _old, string _new); 

     //截取低n位
    string left(string src, unsigned int _offset);

    //截取高n位
    string right(string src, size_t _offset); 

    //去除从nIndex下标开始的nCount位
    int remove(string& str, size_t nIndex = 0, size_t nCount = 1);

    //在指定nIndex下标插入子字符串
    int insert(string& str, size_t nIndex, string& sub);
    int insert(string& str, size_t nIndex, const char* sub);

    //类似sprintf
    int format(string& str, const char* format_str, ...);

    //从最低位开始找到第一个属于指定字符串集合的元素位置
    int findOneOf(string str, const char* c);

    //类似于strncmp
    string SpanIncluding(string &str, const char* sub);

    //复制
    int copy(string& des, string src);
};

#include "stdafx.h"
#include <crtdbg.h>
#include<stdio.h>
#include<stdarg.h>
#include <algorithm>

#include "generalfuns.h"

void string_genral::strupper(string& str)
{
    transform(str.begin(),str.end(),str.begin(),::toupper);
}

void string_genral::strlower(string& str)
{
    transform(str.begin(),str.end(),str.begin(),::tolower);
}

void string_genral::TrimLeft(string& str)
{
    str.erase(0,str.find_first_not_of(' '));
}

void string_genral::TrimRight(string& str)
{
    str.erase(str.find_last_not_of(' ')+1);
}

void string_genral::TrimLeft(string& str, const char* c)
{
    char ch[2] = {0};
    string::iterator iter;

    if (c == NULL)
    {
        return;
    }
    else
    {
        while(str.size())
        {
            iter = str.begin();
            ch[0] = str.at(0);

            if (NULL == strstr(c, ch))
            {
                break;
            }

            str.erase(iter);
        }
    }

    return;
}

void string_genral::TrimRight(string& str, const char* c)
{
    char ch[2] = {0};
    string::iterator iter;

    if (c == NULL)
    {
        return;
    }
    else
    {
        while(str.size())
        {
            iter = str.end() - 1;
            ch[0] = str.at(str.size() - 1);

            if (NULL == strstr(c, ch))
            {
                break;
            }

            str.erase(iter);
        }
    }

    return;
}

int string_genral::DeleteChar(string& str,char ch)
{
    int o_size = str.size();
    str.erase(remove_if(str.begin(),str.end(),bind2nd(equal_to<char>(), ch)),str.end());

    return (o_size - str.size());
}


bool string_genral::StartWith(const string& str,const string& strStart)
{
    if(str.empty() || strStart.empty())
    {
        return false;
    }

    return str.compare(0,strStart.size(),strStart)==0?true:false;
}

bool string_genral::EndWith(const string& str,const string& strEnd)
{
    if(str.empty() || strEnd.empty())
    {
        return false;
    }
    return str.compare(str.size()-strEnd.size(),strEnd.size(),strEnd)==0?true:false;
}

void string_genral::replace_all(string& str, string _old, string _new)
{
    if (str.find(_old) == -1)
    {
        return;
    }

    str.replace(str.find(_old), _old.size(), _new);

    return replace_all(str, _old, _new);
}

string string_genral::left(string src, unsigned int _offset)
{
    string dst("\0");
    string::iterator iter = src.begin();
    if (src.size() < _offset)
    {
        _offset = src.size();
        //return dst;
    }

    iter += _offset;

    dst.append(src.begin(), iter);
    return dst;
}

string string_genral::right(string src, size_t _offset)
{
    string::iterator iter;
    string rst("\0");

    if (_offset < 1 || _offset > src.size())
    {
        return rst;
    }

    iter = src.end() - _offset;
    rst.append(iter, src.end());

    return rst;
}

//已验证
int string_genral::remove(string& str, size_t nIndex, size_t nCount /* = 1 */)
{
    string temp;
    string::iterator iter;

    if (nIndex>= 0 
        && nCount >=0 
        && (nCount + nIndex <= str.size()))
    {
        //temp = str.substr(nIndex, nCount);
        while(nCount)
        {
            iter = str.begin();
            advance(iter, nIndex);  // + nIndex;
            str.erase(iter);
            //iter++;
            nCount--;
            //printf("%d", nCount);
        }

        return str.size() - nCount;
    }


    return -1;
}

//已验证
int string_genral::insert(string& str, size_t nIndex, string& sub)
{
    string::iterator iter;

    if (nIndex < 0 )
    {
        return -1;
    }

    for (int i = 0; i< sub.size() ; i++)
    {
        iter = str.begin() + nIndex;
        str.insert(iter, sub.at(i));
        nIndex++;
    }

    return str.size();
}

int string_genral::insert(string& str, size_t nIndex, const char* sub)
{
    string::iterator iter;

    if (nIndex < 0 )
    {
        return -1;
    }


    for (int i = 0; i < strlen(sub); i++)
    {
        iter = str.begin() + nIndex;
        str.insert(iter, sub[i]);
        nIndex++;
    }

    return str.size();
}

//已验证
int string_genral::format(string& str, const char* format_str, ...)
{
    int rst = 0;
    char _c[2048] = {0};
    va_list _arglist;
    va_start(_arglist, format_str);
    rst = vsprintf(_c, format_str, _arglist);
    va_end(_arglist);
    str = _c;

    return rst;
}

int string_genral::findOneOf(string str, const char* c)
{
    char ch[2] = {0};
    string::iterator iter;

    if (c == NULL)
    {
        return string::npos;
    }

    iter = str.begin();

    for(int i = 0; i < str.size() ;i++)
    {
        ch[0] = str.at(i);

        if (NULL != strstr(c, ch))
        {
            return i;
        }
    }

    return string::npos;
}

//已验证
string string_genral::SpanIncluding(string &str, const char* sub)
{
    char _c[2] = {0};
    string rslt("\0");

    for(int i = 0; i<str.size() ;i++)
    {
        _c[0] = str.at(i);
        if (strstr(sub, _c) != NULL)
        {
            rslt.push_back(_c[0]);
        }
    }

    return rslt;
}

int string_genral::copy(string& des, string src)
{
    int reslt = src.size();

    des.assign(src.begin(), src.end());

    return reslt;
}

//已验证
int ListGet(list<int> _list, size_t nIndex)
{
    int rslt;
    memset(&rslt, 0,sizeof(int));
    list<int>::iterator iter;

    if (_list.size() < (nIndex + 1))
    {
        return rslt;
    }

    iter = _list.begin();
    advance(iter, nIndex);
    rslt = *iter;
    return rslt;
}