引言 UICollectionView 是 iOS 平臺上一種強大的視圖佈局工具，能夠很好地實現網格佈局，列表佈局等多種佈局方式。 首先講下今天的目標，我們將要使用 UICollectionView 來創建仿微博的九宮格內容。首先，目標行數為3，每行顯示3張圖片，總共顯示9張圖片。 實現方式 我們往 ...
std::string詳解
之所以拋棄char*的字元串而選用C++標準程式庫中的string類，是因為他和前者比較起來，不必 擔心記憶體是否足夠、字元串長度等等，而且作為一個類出現，他集成的操作函數足以完成我們大多數情況下(甚至是100%)的需要。我們可以用 = 進行賦值操作，== 進行比較，+ 做串聯（是不是很簡單?）。我們盡可以把它看成是C++的基本數據類型。
標準模板庫（STL）提供了一個std::string類，其是std::basic_string的一個特化，它是一個容器類，可把字元串當作普通類型來使用，並支持比較、連接、遍歷、STL演算法、複製、賦值等等操作，這個類定義在
實現原理
1．聲明一個C++字元串，初始化
std::string類的構造函數聲明一個字元串變數很簡單：string Str;
這樣我們就聲明瞭一個字元串變數，但既然是一個類，就有構造函數和析構函數。上面的聲明沒有傳入參數，所以就直接使用了string的預設的構造函數，這個函數所作的就是把Str初始化為一個空字元串。String類的構造函數和析構函數如下：
- string s(); //生成一個空字元串s
- string s(str) //拷貝構造函數 生成str的複製品string(const string& str)
- string s(const char *s) //將C字元串作為s的初值
- string s(const char* cstr, size_type n) //使用字元串str的前n個字元初始化作為字元串s的初值。
- string s(str,stridx) //將字元串str內"始於位置stridx"的部分當作字元串的初值
- string s(const string& str, size_type pos,strlen) //將字元串str內"始於pos且長度頂多strlen"的部分作為字元串的初值
- string s(int num,char c) //生成一個字元串，包含num個c字元
- string s(begin,end) //以區間beg;end(不包含end)內的字元作為字元串s的初值,即迭代器間的值。
- s.~string() //銷毀所有字元，釋放記憶體
- 註意：當構造的string太長而無法表達時會拋出length_error異常
- 當指定拷貝的長度大於被拷貝字元串的長度時，是將字元串對應位置中剩餘的內容全部拷貝。
2．字元串操作函數
1.賦以新值 = ,assign( )
第一個賦值方法當然是使用操作符=，新值可以是string(如：s=ns) 、c_string(如：s="gaint")甚至單一字元（如：s=’j’）。
還可以使用成員函數assign()，這個成員函數可以使你更靈活的對字元串賦值。註意和string的構造初始化賦值等函數基本類似，只是這個是賦予新值。
s.assign(str);
s.assign(str,1,3);//如果str是"iamangel" 就是把"ama"賦給字元串
s.assign(str,2,string::npos);//把字元串str從索引值2開始到結尾賦給s
s.assign("gaint");
s.assign("nico",3);//把’n’ ‘I’ ‘c’賦給字元串
s.assign("nicoafdad",2,5);//從二開始數五個
s.assign(5,’x’);//把五個x賦給字元串
2.兩個字元串關係：交換swap( ) 比較字元串 ==,!=,< , <= , > , >= , ，compare( )
a.swap(b); //結果為 b="12345678"; a="ABCD"；swap會導致迭代器失效
C ++字元串支持常見的比較操作符（>,>=,<,<=,==,!=），甚至支持string與C-string的比較(如 str<"hello")。在使用>,>=,<,<=這些操作符的時候是根據"當前字元特性"將字元按字典順序進行逐一得 比較。字典排序靠前的字元小，比較的順序是從前向後比較，遇到不相等的字元就按這個位置上的兩個字元的比較結果確定兩個字元串的大小。同時，string ("aaaa") <string(aaaaa)。
另一個功能強大的比較函數是成員函數compare()。他支持多參數處理，支持用索引值和長度定位子串來進行比較。他返回一個整數來表示比較結果，返回值意義如下：0-相等 〉0-大於 <0-小於。舉例如下：
string字元串使用方法都類似
string s("abcd");
s.compare("abcd"); //返回0
s.compare("dcba"); //返回一個小於0的值
s.compare("ab"); //返回大於0的值
s.compare(s); //相等
auto number = b.compare(0,4,"1234efgh",4,4); //結果為 number=0; //字元串b從下標為0的地方開始的後四個字元是efgh，字元串"1234efgh"從下標為4的字元開始的後4個字元是efgh,所以相等
s.compare(1,2,"bcx",2); //用"bc"和"bc"比較。
3.添加插入：在尾部添加字元 += , append() ,push_back( ) 插入字元insert( ) 串聯字元串 +
append和asign和string初始化都差不多，這個是追加，+=和等於也類似的關係
s+=str;//加個字元串
s+="my name is jiayp";//加個C字元串
s+=’a’;//加個字元
s.append(str);
s.append(str,1,3);//不解釋了 同前面的函數參數assign的解釋
s.append(str,2,string::npos)//不解釋了
s.append("my name is jiayp");
s.append("nico",5);
s.append(5,’x’);
s.push_back(‘a’);//這個函數只能增加單個字元
也許你需要在string中間的某個位置插入字元串，這時候你可以用insert()函數，這個函數需要你指定一個安插位置的索引，被插入的字元串將放在這個索引的後面。
string a = "1234";
string b = "5678";
1.在string字元串某一個位置上插入另一個（string）字元串
insert(int,string&);
a.insert(0, b); //結果為 a="56781234";
a.insert(2, b); //結果為 a="12567834";
insert(int,const char*);
a.insert(3,"abcd");//結果為 a="123abcd4";
2.在string字元串某一個位置上插入另一個字元串的前n個字元
insert(int,const char*,int);
a.insert(1,"abcd",2); //結果為 a="1ab234";
3.在string字元串某一位置上插入另一個string字元串（從下標為n的位置開始到結束）
insert(int,string&,int);
a.insert(1,b,2); //結果為 a="178234";
4.在string字元串某一位置上插入另一個(string)字元串（從下標為n的位置開始連續m個字元）
insert(int,string&,int，int);
a.insert(2,b,1,2); //結果為 a="126734";
a.insert(0,b,0,3); //結果為 a="5671234";
insert(int,const char*,int，int);
a.insert(2,"5678",1,2); //結果為 a="126734";
5.在字元串中插入n個字元
insert(int,int,const char);
a.insert(2,5,'k'); //結果為 a="12kkkkk34";
insert(iterator,const char);
a.insert(a.begin()+3,'k'); //結果為 a="123k4";
insert(iterator,int,const char);
a.insert(a.begin()+3,10,'k'); //結果為 a="123kkkkkkkkkk4";
6.在字元串某個位置插入另一個字元串的某一個區間字元
insert(iterator,const_iterator_first,const_iterator_last);
a.insert(a.begin() + 1, b.begin() + 1, b.end() - 1);//結果為 a="167234";
4.取改 單一字元 [ ], at() 替換字元replace()
可以使用下標操作符[]和函數at()對元素包含的字元進行訪問。但是應該註意的是操作符[]並不檢查索引是否有效（有效索引0~str.length()），如果索引失效，會引起未定義的行為。而at()會檢查，如果使用 at()的時候索引無效，會拋出out_of_range異常。
1.獲取string字元串某一個字元 auto s=a.at(1); 2.修改string字元串某一個字元 a.at(2)='1';
使用[]同理；還有stl的迭代器和front(),back()也可以
不贊成類似於下麵的引用或指針賦值：
char& r=s[2];
char* p= &s[3];
因為一旦發生重新分配，r,p立即失效。避免的方法就是不使用。
遍歷所有字元，這可由C風格的索引或STL迭代子來完成（如果無需修改，應使用const_iterator）。
std::string name = "marius";
for(size_t i = 0; i < name.length(); ++i)
std::cout << name[i];
for(std::string::const_iterator cit = name.begin(); cit != name.end(); ++cit)
std::cout << *cit;
for(std::string::iterator it = name.begin();it != name.end(); ++it)
*it = toupper(*it);
string s="il8n";
s.replace(1,2,"nternationalizatio");//從索引1開始的2個替換成後面的C_string
std :: string類的替換函數
函數1：std::string & replace ( (size_type pos1, size_type n1, const std：：string & str, size_type pos2 = 0, size_type n2 = npos )) ;
s1.replace(1, 3, "123456", 2, 4); //用 "123456" 的子串(2,4) 替換 s1 的子串(1,3)
該函數的作用：使用str字元串從位置pos2開始的n2個字元，替換當前字元串從pos1位置開始處的n1個字元。即該函數將當前字元串從pos1開始的n1個字元全部刪除，然後再用str整個字元串或者str從pos2開始的n2個字元，從pos1位置開始填入到當前字元串中。
提醒：如果n1或者n2的數值超出了對應字元串的長度，以實際長度為準，不會出現訪問越界的情況。
註意：函數（1~4)
a、如果pos1指定的位置超出當前字元串的範圍，拋出std::out_of_range異常，不捕捉將導致coredump。
b、如果pos2指定的位置超出替換字元串str的範圍，拋出std::out_of_range異常，不捕捉將導致coredump。
函數2：std::string& replace(size_type pos, size_type n1, const char * s, size_type n2);
該函數的作用：使用字元串s的前n2個字元，替換當前字元串從pos位置開始處的n1個字元。即函數將當前字元串從pos開始的n1個字元全部刪除，然後再用字元串s的前n2個字元填入到當前字元串中。類似於函數1的pos2等於0，必須指定n2的這種情況，但也有一點的差別，下麵會註意里描述這種差別。
a.replace(6, 3, "THJKL", 2); //結果為 a="1234abTH678efgh";
函數3：std::string& replace(size_type pos, size_type n1, const char* s);
s2.replace(n, 5, "XXX"); //將子串(n,5)替換為"XXX"
該函數的作用：使用以''為結尾的字元串s，替換當前字元串從pos位置開始處的n1個字元。即函數將當前字元串從pos開始的n1個字元全部刪除，然後再用字元串s從開始到以''結束的所有字元，從pos位置開始填入到當前字元串中。
函數4：std::string& replace(size_type pos, size_type n1, size_type n2, char c);
該函數的作用：使用n2個c表示的字元，替換當前字元串從pos位置開始處的n1個字元。即函數將當前字元串從pos開始的n1個字元全部刪除，然後再用n2個c字元，從pos位置開始填入到當前字元串中。
s2.replace(2, 3, 5, '0'); //用 5 個 '0' 替換子串(2,3)
函數5：std::string& replace((iterator i1, iterator i2, const std：： string& str));
該函數的作用：使用字元串str，替換當前字元串[i1,i2)之間的字元。
a.replace(a.begin()+5,a.end()-3,b); //結果為 a="1234aABCDfgh";
函數6：std::string& replace(iterator i1, iterator i2, const char* s, size_type n);
該函數的作用：使用字元串s的前n個字元，替換當前字元串[i1,i2)之間的字元。
a.replace(a.begin() + 6, a.end() - 3, "THJKL", 2);//結果為 a="1234abTHfgh";
函數7：std::string& replace(iterator i1, iterator i2, const char* s);
該函數的作用：使用以''結尾的字元串s，替換當前字元串[i1,i2)之間的字元。
a.replace(a.begin()+3,a.begin()+6,"替換"); //結果為 a="123替換cd5678efgh";
函數8：std::string& replace(iterator i1, iterator i2, size_type n, char c);
該函數的作用：使用n個c表示的字元，替換當前字元串[i1,i2)之間的字元。
a.replace(a.begin()+6, a.end()-3, 5, '>');
5.將某值寫入和寫出stream >>,getline()，<<
1．>> 從輸入流讀取一個string
2．<< 把一個string寫入輸出流。
3. 另一個函數就是getline(),他從輸入流讀取一行內容，直到遇到分行符或到了文件尾。istream& getline (istream& is, string& str);std::getline(std::cin, s);getline就可以實現輸入整行字元串，如果需要輸入多行，用一個while嵌套即可：while( getline() )
6.刪除全部字元clear() 刪除nStart—nEnd位置字元erase(int nStart,int nEnd)
把字元串清空的方法有三個：s="";s.clear();s.erase();
在字元串末尾刪除一個字元 a.pop_back(); //結果為 a="12";
1.刪除所有字元
a.erase(); //結果為 a="";
2.從字元串的某一個位置開始刪除
a.erase(n) //從字元串的第n個字元開始刪除
a.erase(3); //結果為 a="123";
a.erase(5); //結果為 a="12345";
a.erase(0); //等同於a.erase() a="";
3.從字元串的某一個位置開始，向後刪除m個字元
a.erase(n,m); //從字元的第n個字元開始刪除m個字元
a.erase(2,3); //結果為 a="126789";
a.erase(4,1); //結果為 a="12346789";
4.刪除迭代器位置處的字元，並返回下一個字元的迭代器
auot iter=a.erase(a.begin()+1); //結果為 a="13456789";
cout<<*iter<<endl; //結果為 *iter=3
5.刪除迭代器所指向的區間,並返回下一個字元的迭代器 auto iter=a.erase(a.begin()+1,a.end()-2);//結果為 a="189";
cout<<*iter<,endl; //結果為 *iter=8;
6.刪除字元時常常與find()函數配合使用(find()函數的用法會在以後寫出)
a.erase(a.find("56"),2); //結果為 a="1234789";
7.stl相關begin() end() rbegin() rend() front和back
std::string name = "marius";
// 使字元串全為大寫
std::transform(name.begin(), name.end(), name.begin(),toupper);
std::string name = "marius";
// 升序排列字元串
std::sort(name.begin(), name.end());
std::string name = "marius";
// 反轉字元串
std::reverse(name.begin(), name.end());
bool iswhitespace(char ch){
returnch == ' ' || ch == 't' || ch == 'v' ||
ch == 'r' || ch == 'n';
}
std::string name = " marius";
// 刪除空白字元
std::string::iterator newend = std::remove_if(name.begin(), name.end(), iswhitespace);
name.erase(newend);
string a="abcd";
1.獲取字元串最後一個字元
auto b=a.back(); //結果為 b='d';
2.修改字元串最後一個字元
a.back()='!'; //結果為 a="abc!";
3.獲取字元串第一個字元
auto b=a.front(); //結果為 b='a';
4.修改字元串第一個字元
a.front()='!'; //結果為 a="!bcd";
string::reverse_iterator rit = s.rbegin();//取開頭是調用rbegin介面
8.查找函數和返回某個子字元串substr()
find()，rfind()，find_first_of()，find_last_of()，find_first_not_of()，find_last_not_of()
這些函數返回符合搜索條件的字元區間內的第一個字元的索引，沒找到目標就返回npos。所有的函數的參數說明：
第一個參數是被搜尋的對象。第二個參數（可有可無）指出string內的搜尋起點索引，第三個參數（可有可無）指出搜尋的字元個數。
find()與rfind()
string a="123456789abcdefgab";
string b="789abc";
如果找不到則返回的值為string::npos
/*if(a.find('k')==string::npos){cout<<"沒有找到"<<endl;}*/
1.在字元串中查找某一個字元
(1).從字元串開始位置開始查找
auto s=a.find('a'); //結果為 s=9;
//表明a在字元串中從左向右第一次出現的位置的下標為9
(2).從字元串某一個位置開始查找
auto s=a.find('a',11); //結果為 s=16
//從字元串下標為11的地方開始查找字元
2.在字元串中查找某一個子串
(1).從字元串開始位置開始查找
auto s=a.find("9a");//結果為 s=8;
//表明9a子串的第一個字元在字元串中從左向右第一次出現的位置下標為8
auto s=a.find(b); //結果為 s=6;
(2).從字元串某一個位置開始查找
auto s=a.find("ab",11); //結果為 s=16
//從字元下標為11的地方開始向後查找
3.在字元串中查找子串的前n個字元
auto s=a.find("abcd",11,2); //結果為 s=16;
//解釋：在字元串a中查找，子串"abcd"的前2個字元即在字元串a中查找"ab"
//註意 在這個重載函數中，第一個參數只能是char* 類型，而不能是string類型
4.find()與rfind()的區別
find()是字元串從前向後查找，rfind()是字元串從後向前查找，其他的用法與find()函數類似
find_first_of()與find_last_of()
string a="123456789abcdefgh";
1.在字元串中查找某一個字元
auto s=a.find_first_of('5');//結果為 s=4;
auto s=a.find_first_of('5',5); //沒有查找到 s=string::npos;
//如果查找某一個字元，與find()函數類似
2.在字元串中查找子串
//此時與find()函數不同，find()函數是查找子串，
//而find_first_of()函數是查找字元串a中含有的任意子串的字元
auto s=a.find_first_of("8a"); //結果為 s=7;
auto s=a.find_first_of("8a",1); //結果為 s=7;
//在字元串a中查找最早出現的字元'8'或者'a';
auto s=a,find("8a"); //結果是找不到
auto s=a,find("8a",1); //結果是找不到
//find()函數查找子串必須是相連的，而find_first_of()不需要，只要字元串中含有子串的字就可以
/*重要
*find_first_of()函數在字元串中查找子串中出現的任意字元，比如在字元串 "12abc"中查找子串"1k"，1在字元串"12abc"中出現過，所以可以找到
*find()函數在字元串"12abc"中查找"1k",則查找不到，它查找的必須是"1k"這兩個相連的字元
*/
3.find_first_of()與find_last_of()的區別
find_first_of()是從前向後查找，而find_last_of()是從後向前查找。其他的用法與find_first_of()函數類似。
find_first_not_of()與find_last_not_of()
find_first_not_of()與find_first_of()功能正好相反。不懂得可以先看我寫的find_first_of()函數功能詳解
find_firat_of()函數是在字元串中查找子串出現過的任意字元，也可以所字元串與子串都有的字元。
find_first_not_of()函數是在字元串中查找子串沒有出現過的任意字元，也可以說是，字元串中有而子串中沒有的字元
//以上查找的結果都是最先出現的那個字元的下標
//例
string a="12345";
auto s=a.find_first_not_of("1238"); //結果為 s=3;
//a字元串中有，而子串沒有的是"45"，而'4'字元是最先出現的，它的下標為3
find_first_not_of(str,n);
//str是子串，n是從下標為n的字元開始查找
find_first_not_of(str,n,m);
//str是子串，n是從下標為n的字元開始查找
//m是只看str子串的前m位字元
find_first_not_of()與find_last_not_of()查找順序正好相反，
find_first_not_of()是從前向後，find_last_not_of()是從後向前查找
//如果以上看不懂的話建議先從find()，rfina()函數看起，之後再看find_first_of()與find_last_of(),最後看find_first_not_of()與find_last_not_of()
最後再說說npos的含義，string::npos的類型是string::size_type,所以，一旦需要把一個索引與npos相比，這個索引值必須是string::size)type類型的，更多的情況下，我們可以直接把函數和npos進行比較（如：if(s.find("jia")== string::npos)）。
s.substr();//返回s的全部內容
s.substr(11);//從索引11往後的子串
s.substr(5,6);//從索引5開始6個字元
// 獲取file的尾碼
void Teststring1(){
string file("string.cpp");
size_t pos = file.rfind('.');
string suffix = file.substr(pos);
cout << suffix << endl;
}
// 取出url中的功能變數名稱
void Teststring2(){
string url("http://www.cplusplus.com/reference/string/string/find/");
cout << url << endl;
size_t start = url.find("://");
//如果沒有://，說明是無效協議
if (start == string::npos) {
cout << "invalid url" << endl;
return;
}
else{
string tmp = url.substr(0, start);//取出協議
cout << tmp << endl;
}
//找到功能變數名稱的起始位置
start += 3;
//查找功能變數名稱的結尾
size_t finish = url.find('/', start);
//取出功能變數名稱
string address = url.substr(start, finish - start);
cout << address << endl;
}
9.返回字元數量size(),length() 返回字元的可能最大個數max_size() 判斷字元串是否為空 empty() 返回重新分配之前的字元容量capacity() 保留一定量記憶體以容納一定數量的字元reserve()
auto s=a.empty(); //結果為 s=false;
- size()和length()，他們等效。Empty()用來檢查字元串是否為空。
- max_size() 這個大小是指當前C++字元串最多能包含的字元數，很可能和機器本身的限制或者字元串所在位置連續記憶體的大小有關係。我們一般情況下不用關心他，應該大小足夠我們用的。
- capacity()重新分配記憶體之前 string所能包含的最大字元數。這裡另一個需要指出的是reserve()函數，這個函數為string重新分配記憶體。重新分配的大小由其參數決定， 預設參數為0，這時候會對string進行非強制性縮減。
-
a.reserve(20); reserve(size_t);可以調整string的空間。 如果size_t大於capacity的容量，則capacity按n*16-1擴大到比size_t 如果size_t小於capacity，則capacity不變 -
a.resize(40); resize(size_t);可以調整string的空間。 可以改變string size的大小，並且capacity隨size變大而變大，但是不會減小，當size縮小後，字元超出的部分會被裁剪掉。 a.resize(40,'A'); 擴充size後可以輸入預定字元進行填充 //結果為 a="1234AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
10.與c語言字元串： 將某值賦值為一個C_string，copy() 將內容以C_string返回 c_str() 將內容以字元數組形式返回data()
data()以字元數組的形式返回字元串內容，但並不添加’\0’。c_str()返回一個以‘\0’結尾的字元數組，而copy()則把字元串的內容複製或寫入既有的c_string或字元數組內。C++字元串並不以’\0’結尾char*為C編程中最常用的字元串指針，一般以’\0′為結束標誌；
char *str = new char[64];
string a="12345abcdefg6789";
str[a.copy(str,7,5)]='\0'; // 結果為 str="abcdefg";
str[a.copy(str,7)]='\0'; // 結果為 str="12345ab";
delete[]str; /*註意 *copy的第2，3個參數不能大於字元串str所能容納的最長字元串長度 */
str=a.c_str(); str=a.data();//a改變，str也隨之改變
//可以生成一個const char* 的指針，可以指向一個空字元終止的地址。 const char* str=nullptr;
c語言中字元串在stdlib.h中有atoi和strtod等字元串轉為數字的函數而string可以自己定義萬能轉換函數
* 轉string * *為i，l，f，d
string *tos(* i){ // 改一下函數名，改一下類型，搞定
ostringstream os;
os<<i;
string result;
istringstream is(os.str());
is>>result;
return result;
}//將 * 換成想要的類型就可以執行 * 轉 string
*string *
* sto*(string str){ // 改一下函數名，變數類型，搞定
* result;
istringstream is(str);
is >> result;
return result;
}//將 * 換成想要的類型就可以執行 string 轉 *
//也可以重載函數，達到萬能函數轉換
//記得包含頭文件 #include <sstream>
//總結：使用 string 流和標準 io 流其實本身就是流，一個原理的，不同調用方法。
註意：前導0，長度
string常見操作
- 把字元串轉換成整數
/*首先，這個題不考慮字母*/ /*那就簡單多了，只考慮數字，遇到其他情況直接返回-1就行了*/ class Solution { public: int StrToInt(string str) { int ans = 0;int isplus = 1; for(char ch:str){ if(isalpha(ch)){ return 0; }if (ch == '+' || ch =='-'){ isplus = (ch == '+') ? 1 : -1; }if(isdigit(ch)){ ans = ans*10+ch-'0'; } }return isplus*ans; } }; - 字元串相加("123"+"23"="146")
string addStrings(string num1, string num2) {
string str;
int cur = 0, i = num1.size()-1, j = num2.size()-1;
while (i >= 0 || j >= 0 || cur != 0) {
if (i >= 0) cur += num1[i--] - '0';
if (j >= 0) cur += num2[j--] - '0';
str += to_string (cur % 10);//將int轉換位string；string num = to_string(sum);
cur /= 10;
}
reverse(str.begin(), str.end());
return str;
string addStrings(string num1, string num2) {
int i = num1.length() - 1, j = num2.length() - 1, add = 0;
string ans = "";
while (i >= 0 || j >= 0 || add != 0) {
int x = i >= 0 ? num1[i] - '0' : 0;
int y = j >= 0 ? num2[j] - '0' : 0;
int result = x + y + add;
ans.push_back('0' + result % 10);
add = result / 10; i -= 1; j -= 1;
}
// 計算完以後的答案需要翻轉過來
reverse(ans.begin(), ans.end());
return ans;
}
}
const string a;的操作符[]對索引值是a.length()仍然有效，其返回值是’’。其他的各種情況，a.length()索引都是無效的。舉例如下：
const string Cstr("const string");
string Str("string");
Str[3]; //ok
Str.at(3); //ok
Str[100]; //未定義的行為
Str.at(100); //throw out_of_range
Str[Str.length()] //未定義行為
Cstr[Cstr.length()] //返回 ‘’
Str.at(Str.length());//throw out_of_range
Cstr.at(Cstr.length()) throw out_of_range
