C++ string的那些坑，C++ string功能補充（類型互轉，分割，合並，瘦身） ，c++ string的內存本質（簡單明了的一個測試）

 

1. size_type find_first_of( const basic_string &str, size_type index = 0 ); 

查找在字符串中第一個與str中的某個字符匹配的字符，返回它的位置。搜索從index開始，如果沒找到就返回string::npos

2. string& replace (size_t pos, size_t len, const string& str);

從當前字符串的pos位置開始，長度為len的段落，替換成成str

3. int compare (const string& str) 

結果為0，表示字符串相等，等價於字符串間的=

4. data()與c_str()的區別

data()是指返回字符數組，尾部可能有'\0'，也可能沒有.

c_str()是指返回C兼容的字符串，尾部肯定有'\0'

5. at()與[]的區別

[]沒有檢查越界，不會拋出異常，效率高

at()檢查越界，拋出異常，安全度高

6.size_t copy (char* s, size_t len, size_t pos = 0) const;

將strign的內容拷貝到外部的一個字符數組中，而不是將外部的字符串拷貝到string

7.size()和length()

size()返回string的長度，是字節數，而不是字符個數。string無視內部字符采用的是何種編碼方式，它都當成字節集合來處理。size()和length()功能和意義一樣，前者是為了配合STL標准加的接口。

http://www.cnblogs.com/guoxiaoqian/p/4275959.html

 

int StringUtil::intFromString(string data)
{
    //NOTE atoi是非標准C函數
    return atoi(data.c_str());
}
string StringUtil::stringFromInt(int data)
{
    char tmp[11];
    memset(tmp,0,11);
    sprintf(tmp,"%10d",data);
    return string(tmp);
}
double StringUtil::doubleFromString(string data)
{
    double tmp;
    sscanf(data.c_str(),"%lf",&tmp);
    return tmp;
}
string StringUtil::stringFromDouble(double data)
{
    char tmp[21];
    memset(tmp,0,21);
    sprintf(tmp,"%20.3lf",data);
    return string(tmp);
}
float StringUtil::floatFromString(std::string data)
{
    float tmp;
    sscanf(data.c_str(),"%f",&tmp);
    return tmp;
}
std::string StringUtil::stringFromFloat(float data)
{
    char tmp[21];
    memset(tmp,0,21);
    sprintf(tmp,"%20.3f",data);
    return string(tmp);
}
bool StringUtil::boolFromString(std::string data)
{
    if(data.compare("true") == 0)
        return true;
    else
        return false;
}
std::string StringUtil::stringFromBool(bool data)
{
    if(data)
        return string("true");
    else
        return string("false");
}
vector<std::string> StringUtil::splitStringToArray(std::string source, std::string seperator)
{
    vector<string> result;
    if(!source.empty())
    {
        string::size_type begin = 0;
        string::size_type end = 0;
        unsigned int sepSize = seperator.size();
        while((end = source.find_first_of(seperator,begin))!=string::npos)
        {
            string item = source.substr(begin,end-begin);
            result.push_back(item);
            begin=end + sepSize;
        }
        //last item,注意如果最后是分割符，則最后的元素為空字符串
        if(begin <= source.size())
        {
            string item = source.substr(begin,source.size() - begin);
            result.push_back(item);
        }
    }
    return result;
}
std::string StringUtil::linkArrayToString(vector<std::string> array, std::string seperator)
{
    string result;
    if(array.size() > 0)
    {
        unsigned int limit = array.size() - 1;
        for(unsigned int i=0;i< limit;++i)
        {
            result+=array[i];
            result+=seperator;
        }
        result += array[limit];
    }
    return result;
}
map<std::string, std::string> StringUtil::splitStringToMap(std::string source, std::string primarySep, std::string secondarySep)
{
    vector<string> array = StringUtil::splitStringToArray(source,primarySep);
    vector<string> tmpArray;
    map<string,string> result;
    for(unsigned int i = 0; i< array.size();++i)
    {
        tmpArray = StringUtil::splitStringToArray(array[i],secondarySep);
        if(tmpArray.size() >= 2)
        {
            result[tmpArray[0]] = tmpArray[1];
        }
    }
    return result;
}
std::string StringUtil::linkMapToString(map<std::string, std::string> tmpMap, std::string primarySep, std::string secondarySep)
{
    vector<string> tmpArray;
    string tmpStr;
    map<string,string>::iterator it = tmpMap.begin();
    for(;it!=tmpMap.end();++it)
    {
        tmpStr = it->first+secondarySep+it->second;
        tmpArray.push_back(tmpStr);
    }
    return StringUtil::linkArrayToString(tmpArray,primarySep);
}
std::string StringUtil::trimFront(std::string data)
{
    unsigned int i = 0;
    for(;i<data.size()&&data.at(i)==' ';++i)
    {
    }
    if(i<data.size())
        return data.substr(i,data.size()-i);
    else
        return string("");
}
std::string StringUtil::trimBack(std::string data)
{
    int i = data.size()-1;
    for(;i>=0&&data.at(i)==' ';--i)
    {
    }
    if(i>=0)
        return data.substr(0,i+1);
    else
        return string("");
}
std::string StringUtil::trim(std::string data)
{
    string tmp = StringUtil::trimFront(data);
    return StringUtil::trimBack(tmp);
}

http://www.cnblogs.com/guoxiaoqian/p/4113339.html

 

雖然沒有研究過string的源代碼，不過可以確定的是string的內存空間是在堆上開辟的，它自己負責釋放空間，不用我們關系。

 我們用一個動態分配的字符串指針初始化一個string對象retStr，它會做一個拷貝過程，將字符串考到retStr自己的內存空間里，之后retStr就跟ret沒有任何關系了，因此我們要記得釋放ret：

1 char* ret = (char*)malloc(len_str);
2 memset(ret,0,len_str);
3 //operate ret  ...
4 string retStr(ret);
5 free(ret);

http://www.cnblogs.com/guoxiaoqian/p/3944805.html