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;
}