string的初始化
1.常见初始化方式
string对象的初始化和普通类型变量的初始化基本相同，只是string作为类，还有类的一些特性：使用构造函数初始化。如下表，第2 4 6条是作为类才有的初始化方式：
当然，也可以用下面这种格式初始化，其实就是调用string的构造函数生成一个临时的string类，再用临时的string类初始化s5 s6。
string s5 = string("value");
string s6(string("value"));
区别初始化和赋值操作：
区别其实很简单，初始化是生成对象的时候（也就是刚分配内存空间时）就给它值；赋值就是过了初始化后，给对象值。下面的例子就是给st1赋值：
string st1, st2(2,'b');
st1 = st2; //st1此时已近占据了一块内存
string对象的操作
1.用cin获取键盘输入的值
用法很简单，和int、double等内置类型的cin一样使用。不过需要说明一点：
string对象会自动忽略开头的空白（既空格、换行符、制表符等），并从第一个真正的字符开始读入，直到遇到下一处空白
看下面的示例：
string s1;
cin >> s1;
cout << s1 << endl;
忽略了输入Hello world前的空白。从H开始读取字符，在o后面遇到了一处空白，此时不再读取后面的字符。注意，world其实还在缓冲区内，如果再用cin读取，你无法从键盘输入，会直接读到world。
2.用getline读取一整行
getline的函数格式：getline(cin,string对象)
getline的作用是读取一整行，直到遇到换行符才停止读取，期间能读取像空格、Tab等的空白符。实例如下：
string s1;
getline(cin, s1);
cout << s1 << endl;
注意：getline函数和cin一样，也会返回它的流参数，也就是cin，所以可以用getline循环读取一行：
string s1;
while(getline(cin, s1))
cout << s1 << endl;
4.比较string的大小
直接给出例子：
string str = "Hello";
string phrase = "Hello ";
尽管两者的前面对应的字符都一样，但是phrase长度长（多一个空格），所以phrase>str。
string str2 = "Hello";
string phrase2 = "Hi ";
这种情况比较的是第一个相异字符，根据字符值比较大小，因为i的字符值>e的字符值，所以phrase2> str2。
总结：看上面两种情况，实际上可以都看成是一个一个字符比较。对于第一种，str最后为空，而phrase为空格，空格字符值不为负，所以phrase>str。
5.两个string对象相加
5.1 两个string对象相加
string str = "Hello,";
string phrase = "world ";
string s = str + phrase;
str += phrase;//相当于str = str + phrase
cout << s << endl;
cout << str << endl;
5.2 string对象加上一个字符（或字符串）字面值
首先问一个问题：为什么string对象可以加上字符或字符串字面值？实际上是因为它们可以自动转换为string类型。下面看例子：
string str = "Hello";
string phrase = "world";
string s = str + ','+ phrase+ '\n';
cout << s ;
- 1
- 2
- 3
- 4
- 5
判断下面的加法是否正确？
string str = "Hello";
- 1
(1)string s2 = str + "," + "world";(2)string s3 = "Hello" + "," + str;
答案：(1)正确；(2)错误
(2)错误的原因是：当string对象和字符或字符串字面值相加时，必须确保+号的两侧的运算对象至少有一个string。
至于(1)，需要明白，str + “,”会返回一个string类。
如何获取和处理string中的每个字符
1.使用下标运算符[]
直接看下面的例子：
string s = "Hello world!";
cout << s[0] << endl;
cout << s[s.size()-1] << endl;
cout << s << endl;
s[0] = 'h';
cout << s << endl;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
可以通过下标来遍历整个string对象：
string s = "Hello world!";
for (decltype(s.size()) index = 0; index != s.size(); index++){
cout << s[index] << ",";
}
cout<<endl;
- 1
- 2
- 3
- 4
- 5
这里把index的类型声明为s.size()的返回类型：string::size_type，它是无符号类型。当然你也可以用其他类型，但是请注意，下标值不能超过string.size()-1,否则会产生不可预知的结果。
decltype使用可参考：有auto为什么还要decltype ?详解decltype的用法
2.使用迭代器
看下面的例子：
string s = "Hello world!";
for (auto i = s.begin(); i != s.end(); i++){
cout << *i << ",";
}
cout << endl;
- 1
- 2
- 3
- 4
- 5
当然，获取每个字符后，你可以做一些处理，比如讲小写改大写等。
3.使用基于范围的for语句
基于范围的for语句是C++11新提供的一种语句，其语法形式是：
declaration：定义一个变量，它每次的值都是expression中的基础元素
expression：一个已经定义的对象（变量）
statement：具体的语句
这样看上去还不明白的话，请看下面的例子，通过例子就可以很好理解：
string str("some string");
for (auto c : str)
cout << c << ",";
cout << endl;
- 1
- 2
- 3
- 4
c就是declaration；str就是expression；cout << c << “,”;就是statement。
for循环把c和str联系起来了。此例中，通过auto关键字让编译器推断c的类型，c这里的类型实际上推断出的是char类型，c每次的值都是str中的一个字符，上述代码的运行的结果如下：
当你需要修改str中的字符时，你可以使用引用，既：for (auto &c : str)。
关于基于范围的for的使用：C++基于范围的for循环：for(auto a:b)
构造string对象的其他方法
1拷贝数组
形式：string s(cp,n)解释：将cp所指的数组的前n个字符拷贝给string对象s，n为可选参数。
直接看下面的例子：
定义3个字符数组，注意： cp和cp2以空字符结尾，cp3没有空字符结尾。
const char *cp = "hello world";//最后有一个空字符
char cp2[] = "hello world";//最后有一个空字符
char cp3[] = { 'h', 'e' };//最后没有空字符
- 1
- 2
- 3
(1) string s1(cp);//s1为”hello world”，长度为11
(2) string s2(cp2);//s2为”hello world”，长度为11
(3) string s3(cp3);//因为cp3不以空字符结尾，所以这是未定义行为
(4) string s4(cp,5);//s4为”hello”，长度为5。将cp改为cp2一样
(5) string s5(cp,13);//s5为”hello world ”，长度为13,后面有两个空字符。将cp改为cp2一样
(6) string s6(cp3,2);//s6为”he”，长度为2
- 1
- 2
- 3
- 4
- 5
- 6
- 7
2.拷贝string对象
形式：
- string s(s1,pos)
- string s(s1,pos,len)
解释：
- 第一个将s1从下标pos开始拷贝到结尾。当pos>s1.size()时，为未定义行为；当pos=s1.size()，拷贝一个空字符
- 第二个将s1从下标pos开始拷贝，拷贝len个字符。当pos>s1.size()时，为未定义行为；当pos=s2.size()，拷贝一个空字符
例子：
string s1("value");
(1) string s2(s1, 1);//s2为” alue”,长度为4
(2) string s3(s1, 5);//s3为””,长度为0
(3) string s8(s1, 6);// 错误，未定义的行为，抛出异常
(4) string s4(s1, 1,3);// s4为” alu”,长度为3
(5) string s5(s1, 1,8);// 正确，s5为” alue”,长度为4
(6) string s6(s1, 5,8);// s6为””,长度为0
(7) string s7(s1, 6,1);// 错误，未定义的行为，抛出异常
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
总结：相比于数组，拷贝string对象时，只能拷贝到string的结尾，这一点可以看数组的(5)和string对象(5)。
3.使用substr成员函数
格式：s.substr(pos,n)解释：返回一个string对象，返回的对象包含s从pos下标开始的n个字符。pos和n均为可选参数。pos默认为下标0；n默认为s.size()-pos。示例：
string s ("value");
(1)string s2 = s.substr();//s2为”value”,大小为5
(2)string s3 = s.substr(2);//s3为”lue”,大小为3
(3)string s4 = s.substr(5);//s3为””,大小为0
(4)string s5 = s.substr(6);//错误，s5的大小为pos = 5，小于s.size()
(5)string s6 = s.substr(1,2);// s6为”al”,大小为2
(6)string s7 = s.substr(1,7);// s7为”alue”,大小为4
(7)string s8 = s.substr(5,7);// s8为””,大小为0
(8)string s9 = s.substr(6,7);// 错误，s9的大小为pos = 5，小于s.size()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
总结：和第2部分“拷贝string对象”的形式2基本相同。
string对象的insert()
string的insert操作有两种版本的insert：除了顺序容器通用的迭代器版本外还可以使用下标版本。下面分别介绍这两种版本。
迭代器insert
有4种形式：
- iterator insert( iterator pos, CharT ch )
- void insert( iterator pos, size_type count, CharT ch )
- void insert( iterator pos, InputIt first, InputIt last )
- 插入初始化列表
因为是顺序容器通用的迭代器版本，这里不过多介绍，只简单举例说明一下使用。
在list容器的insert操作中，我详细介绍了insert的使用，感兴趣可以看看。C++ STL::list常用操作及底层实现（中1）——实现list常用操作之插入(insert、push_front、push_back、splice)
pos是调用insert的string对象的迭代器位置；ch是单个字符；count是ch的个数。下面是例子。
string s1("value");
s1.insert(s1.begin(), 's');//执行后，s1为"svalue"
s1.insert(s1.begin(), 1, 's');//执行后，s1为"ssvalue"
s1.insert(s1.begin(), s1.begin(), ++s1.begin());//执行后，s1为"sssvalue"
s1.insert(s1.end(), {'1','2'});//执行后，s1为"sssvalue12"
- 1
- 2
- 3
- 4
- 5
- 6
下标insert
- basic_string& insert( size_type index, size_type count, CharT ch )
解释：在下标index前插入count个字符ch。
例子：
string s1("value");
s1.insert(0,2,’s’); //执行后，s1为” ssvalue”
s1.insert(5,2,’s’); //执行后，s1为” valuess”
- basic_string& insert( size_type index, const CharT* s );
basic_string& insert( size_type index, const basic_string& str );
解释：在下标index前插入一个常量字符串或者string对象。
例子：
string s1("value");
string s3 = "value";
const char* cp = "value";
s1.insert(0,s3);//执行完后，s1为" valuevalue"
s1.insert(0,cp); //执行完后，s1为" valuevalue"
- basic_string& insert( size_type index, const basic_string& str,
size_type index_str, size_type count );
解释：在下标index前插入str中的从str[index_str]开始的count个字符
例子：
string s1("value");
string s3 = "value";
const char* cp = "value";
下面在s1的下标0前插入s3的从s3[1]开始的2个字符
s1.insert(0,s3,1,2);//执行后，s1为” alvalue”
- basic_string& insert( size_type index, const CharT* s, size_type count );
解释：在index前插入常量字符串的count个字符
例子：
string s1("value");
const char* cp = "value";
下面在s1的下标0前插入cp的前3个字符
s1.insert(0, cp,3); //执行后，s1为” valvalue”
string对象的erase()
erase有3种形式，其方法原型如下：
basic_string & erase(size_type pos=0, size_type n=npos)
解释：如果string对象s调用，它删除s从pos下标开始的n个字符，并返回删除后的s。当pos > s.size()时，报错
iterator erase(const_iterator position)
解释：如果string对象s调用，它删除s迭代器position位置的字符，并返回下一个字符的迭代器。
iterator erase(const_iterator first, const_iterator last)
解释：如果string对象s调用，它删除s迭代器[first,last)区间的字符，并返回last字符的迭代器。
例子：
string s1("value");
string s2("value");
string s3("value");
string s4("value");
s1.erase();//执行后，s1为空
s2.erase(0,2); //执行后，s2为”lue”
s3.erase(s3.begin());//执行后，s3为”alue”
s4.erase(s4.begin(),++s4.begin());//执行后，s4为”alue”
string对象的append()和replace()
1. append()
append是在string对象的末尾进行插入操作。这一点使用+运算符也能做到。
string s("i love China!");
s.append("forever");//执行完后，s=” i love China! forever”
2. replace()
replace可看作是erase和insert的结合体，它删除指定的字符，删除后再插入指定的字符。
和insert一样，可以通过下标或者是迭代器指定位置。
情形1：下标指定删除的位置
string s("i very love China!");
const char* cp1 = "truly";
const char* cp2 = "truly!!!";
string str1 = "really";
string str2 = "really!!!";
//1.将s从下标2开始删除4个字符，删除后在下标2处插入cp1
s.replace(2,4,cp1);//s=” i truly love China!”
//2.将s从下标2开始删除5个字符，删除后在下标2插入cp2的前5个字符
s.replace(2, 5, cp2,5); //s=” i truly love China!”
//3.将s从下标2开始删除5个字符，删除后在下标2插入str1
s.replace(2, 5, str1);//s=”i really love China!”
//4.将s从下标2开始删除6个字符，删除后在下标2插入str2从下标0开始的6个字符
s.replace(2, 6, str2,0,6);//s=”i really love China!”
//5.将s从下标2开始删除6个字符，删除后在下标2插入4个’*’字符
s.replace(2, 6, 4, '*');//s=”i **** love China!”
情形2：迭代器指定删除的位置
string s1("bad phrase");
const char* cp3 = "sample";
const char* cp4 = "sample!!!";
string str3 = "useful";
string str4 = "useful!!!";
//1.删除[s1.begin(),s1. begin()+3)区间字符，删除后插入cp3
s1.replace(s1.begin(),s1.begin()+3,cp3);//s1="sample phrase"
//2.删除[s1.begin(),s1. begin()+6)区间字符，删除后插入cp4的前6个字符
s1.replace(s1.begin(),s1.begin()+6,cp4,6);//s1="sample phrase"
//3.删除[s1.begin(),s1. begin()+6)区间字符，删除后插入str3
s1.replace(s1.begin(),s1.begin()+6, str3);//s1="useful phrase"
//4.删除[s1.begin(),s1. begin()+6)区间字符，删除后插入str4[str4.begin(),str4. begin()+6)区间字符
s1.replace(s1.begin(),s1.begin()+6, str4.begin(),str4.begin() + 6);//s1="useful phrase"
//5. 删除[s1.begin(),s1. begin()+6)区间字符，删除后插入4个’*’字符
s1.replace(s1.begin(),s1.begin()+6, 4, '*');//s1="**** phrase"
//6. 删除[s1.begin(),s1. begin()+4)区间字符，删除后插入初始化列表
s1.replace(s1.begin(), s1.begin() + 4, {'3','4','5'});//s1="345 phrase"
总结insert和replace
这两个成员函数有太多的参数形式，如何更好的记忆呢？看下表：
说明如下
pos：下标位置
len：个数
b\e\b2\e2：迭代器指向的位置，如begin() end()等
n,c：n个字符c
str：字符串str
cp：cp指向以空字符结尾的字符数组
总结表格：
- 使用了下标标识位置的，其args参数不能含有迭代器；使用了迭代器标识位置的，其args参数不能含有下标信息；
- cp和cp,len是一对；str和str,pos,len是一对
- args为初始化列表只能在用迭代器标识位置时使用
- 注意：上表还有一种情况没有列出，既insert可以直接插入一个字符，如(s.begin(),’’)；所以在insert初始化列表时，初始化列表不能有单个字符如{‘’}，使用vs2013编译器会报错“对重载函数的调用不明确”。
string对象的assign()
assign方法可以理解为先将原字符串清空，然后赋予新的值作替换。
格式如下，可以发现，就输入参数而言，和“总结insert和replace”这一节中的表的args参数是一样的，这里不在多做说明，直接给出7个例子，在例子中说明。
- string& assign (const string& str);
- string& assign (const string& str, size_t subpos, size_t sublen);
- string& assign (const char* s);
- string& assign (const char* s, size_t n);
- string& assign (size_t n, char c);
- template string& assign (InputIterator first, InputIterator last);
- string& assign (initializer_list il);
实例：
std::string str;
std::string base = "The quick brown fox jumps over a lazy dog.";
//1.参数形式1
str.assign(base);
std::cout << str << '\n';
//2.参数形式2：将base从下标10开始的9个字符赋值给str
str.assign(base, 10, 9);
std::cout << str << '\n'; // "brown fox"
//3.参数形式4：将"pangrams are cool"的前7个字符赋值给str
str.assign("pangrams are cool", 7);
std::cout << str << '\n'; // "pangram"
//4.参数形式3：将"c-string"赋值给str
str.assign("c-string");
std::cout << str << '\n'; // "c-string"
//5.参数形式5：将10个字符'*'赋值给str
str.assign(10, '*');
std::cout << str << '\n'; // "**********"
//6.参数形式6：将[base.begin() + 16, base.end() - 12)赋值给str
str.assign(base.begin() + 16, base.end() - 12);
std::cout << str << '\n'; // "fox jumps over"
//7.参数形式7：将初始化列表{'l','o','v','e'}赋值给str
str.assign({ 'l', 'o', 'v', 'e' });
std::cout << str << '\n'; // "love"
string对象的搜索操作
string提供6个不同的搜索函数，每个函数都有4个重载版本，所有函数的返回值都为string::size_type值，表示匹配发生位置的下标。
函数形式：
| string搜索函数 | 描述 |
|---|---|
| s.find(args) | 在s中查找第一次出现args的下标 |
| s.rfind(args) | 在s中查找最后一次出现args的下标 |
| s.find_first_of(args) | 在s中查找第一个在args中出现的字符，返回其下标 |
| s.find_first_not_of(args) | 在s中查找第一个不在args中出现的字符，返回其下标 |
| s.find_last_of(args) | 在s中查找最后一个在args中出现的字符，返回其下标 |
| s.find_last_not_of(args) | 在s中查找最后一个不在args中出现的字符，返回其下标 |
其中args参数格式如下：
| args参数格式 | 描述 |
|---|---|
| c,pos | 搜索单个字符。从s中位置pos开始查找字符c。pos可省略，默认值为0 |
| s2,pos | 搜索字符串。从s中位置pos开始查找字符串string对象s2。pos可省略，默认值为0 |
| cp,pos | 搜索字符串。从s中位置pos开始查找指针cp指向的以空字符结尾的C风格字符串。pos可省略，默认值为0 |
| cp,pos,n | 从s中位置pos开始查找指针cp指向的数组的前n个字符。 |
搜索函数实例
注：
- 下面的例子均参考自http://www.cplusplus.com/reference/string/string/find/。
- std::string::npos是string类中定义的一个std::size_t类型变量，值为std::size_t类型的最大值。
1.find()函数的实列
下面的例子包含了args对应的4种参数形式。在后面介绍其他函数时将不在针对args都给出例子。
std::string str("There are two needles in this haystack with needles.");
std::string str2("needle");
//1.对应参数args为s2，pos
std::size_t found = str.find(str2);//返回第一个"needles"n的下标
if (found != std::string::npos)
std::cout << "first 'needle' found at: " << found << '\n';
//2.对应参数args为cp，pos, n
found = str.find("needles are small", found + 1, 6);
if (found != std::string::npos)
std::cout << "second 'needle' found at: " << found << '\n';
//3.对应参数args为cp，pos
found = str.find("haystack");
if (found != std::string::npos)
std::cout << "'haystack' also found at: " << found << '\n';
//4.对应参数args为c，pos
found = str.find('.');
if (found != std::string::npos)
std::cout << "Period found at: " << found << '\n';
// 替换第一个needle:
str.replace(str.find(str2), str2.length(), "preposition");
std::cout << str << '\n';
2.rfind()函数实例
把最后一个”sixth”换成” seventh”。
cout << " rfind()函数：" << endl;
std::string str("The sixth sick sheik's sixth sheep's sick.");
std::string key("sixth");
std::size_t found = str.rfind(key);//找到最后一个sixth的下标
if (found != std::string::npos)
str.replace(found, key.length(), "seventh");//替换找到的sixth
std::cout << str << '\n';
3.find_first_of()函数例子
把str中的所有元音字母aeiou换成*。
std::string str("Please, replace the vowels in this sentence by asterisks.");
std::size_t found = str.find_first_of("aeiou");
while (found != std::string::npos)
{
str[found] = '*';
found = str.find_first_of("aeiou", found + 1);
}
std::cout << str << '\n';
4.find_first_not_of函数例子
找到str中的第一个非小写字母或空格的字符。
std::string str("look for non-alphabetic characters...");
std::size_t found = str.find_first_not_of("abcdefghijklmnopqrstuvwxyz ");
if (found != std::string::npos)
{
std::cout << "The first non-alphabetic character is " << str[found];
std::cout << " at position " << found << '\n';
}
5.find_last_of函数例子
SplitFilename()函数是将str1和str2中的文件名和文件名所在路径分开并打印。注意，str2中有两个\，其中第一个是转义字符。同样，find_last_of()中的\的第一个也是转义字符。
#include <iostream> // std::cout
#include <string> // std::string
#include <cstddef> // std::size_t
void SplitFilename (const std::string& str)
{
std::cout << "Splitting: " << str << '\n';
std::size_t found = str.find_last_of("/\\");
std::cout << " path: " << str.substr(0,found) << '\n';
std::cout << " file: " << str.substr(found+1) << '\n';
}
int main ()
{
std::string str1 ("/usr/bin/man");
std::string str2 ("c:\\windows\\winhelp.exe");
SplitFilename (str1);
SplitFilename (str2);
system("pause");
return 0;
}
6.find_last_not_of()例子
查找最后一个不是whitespaces对象的字符，并删除(erase函数)此字符后面的所有字符。
std::string str("Please, erase trailing white-spaces \n");
std::string whitespaces(" \t\f\v\n\r");
std::size_t found = str.find_last_not_of(whitespaces);
if (found != std::string::npos)
str.erase(found + 1);
else
str.clear(); // str is all whitespace
std::cout << '[' << str << "]\n";
string对象的compare操作
在前面，我们介绍了用比较运算符比较两个字符串的方法，同时string对象中有一个成员函数compare，它也可以比较字符串，并且有6种不同的参数形式，比较字符串时更加灵活。compare的参数形式如下：
| 参数形式s.compare() | 说明 |
|---|---|
| s2 | 比较s和s2 |
| pos1, n1, s2 | 将s中从pos1开始的n1个字符与s2比较 |
| pos1, n1, s2, pos2, n2 | 将s中从pos1开始的n1个字符与s2中从pos2开始的n2个字符比较 |
| cp | 比较s与cp指向的以空字符结尾的数组 |
| pos1, n1, cp | 将s中从pos1开始的n1个字符与cp指向的以空字符结尾的数组比较 |
| pos1, n1, cp,n2 | 将s中从pos1开始的n1个字符与cp指向的以空字符结尾的数组前n个字符比较 |
注意：
- 若s=指定的字符串，s.compare()返回0
- 若s>指定的字符串，s.compare()返回正数
- 若s<指定的字符串，s.compare()返回负数
例子：
std::string str1("green apple");
std::string str2("red apple");
//1.str1和str2比较：参数形式1
if (str1.compare(str2) != 0)
std::cout << str1 << " is not " << str2 << '\n';
//2.str1的下标6开始的5个字符和"apple"比较：参数形式5
if (str1.compare(6, 5, "apple") == 0)
std::cout << "still, " << str1 << " is an apple\n";
//3.str2的下标str2.size() - 5（就是下标6）开始的5个字符和"apple"比较：参数形式5
if (str2.compare(str2.size() - 5, 5, "apple") == 0)
std::cout << "and " << str2 << " is also an apple\n";
//4.str1的下标6开始的5个字符和str2的下标4开始的5个字符比较：参数形式3
if (str1.compare(6, 5, str2, 4, 5) == 0)
std::cout << "therefore, both are apples\n";
//5.str1的下标6开始的5个字符和"apple pie"的前5个字符比较：参数形式6
if (str1.compare(6, 5, "apple pie",5) == 0)
std::cout << "apple pie is maked by apple\n";
//6.str1和"poisonous apple"比较：参数形式4
if (str1.compare("poisonous apple") < 0)
std::cout << "poisonous apple is not a apple\n";
字符串和数值间的转换
格式和说明如下：
注意：
- std::to_string()有9种重载形式，分别对应int/long /long long/unsigned/unsigned long/unsigned long long/float/double/long double。
- b默认值为10，即10进制；若b = 0，则表示自动确定string序列的基数，如0x7f会自动以16进制为基数。
- 对于转换为浮点型的字符串(上述表格的最后3个)，可以识别小数点和指数e、E，如
std::stod(".3e3")结果为300。
to_string 例子
std::string pi = "pi is " + std::to_string(3.1415926);
std::string perfect = std::to_string(1 + 2 + 4 + 7 + 14) + " is a perfect number";
std::cout << pi << '\n';
std::cout << perfect << '\n';
stoi(s,p,b) 例子（stol stoll stoul stoull类似，不再举例）
std::string str_dec = "2001, A Space Odyssey";
std::string str_hex = "40c3";
std::string str_bin = "-10010110001";
std::string str_auto = "0x7f";
std::string::size_type sz; // alias of size_t
//1.转换基数为10进制，sz保存','下标，i_dec = 2001
int i_dec = std::stoi(str_dec, &sz);
//2.转换基数为16进制。所以i_hex = 0x40c3,十进制为16579
int i_hex = std::stoi(str_hex, nullptr, 16);
//3.转换基数为2进制。所以i_bin = -10010110001B,十进制为-1201
int i_bin = std::stoi(str_bin, nullptr, 2);
//4.自动确定 转换基数
int i_auto = std::stoi(str_auto, nullptr, 0);
std::cout << str_dec << ": " << i_dec << " and [" << str_dec.substr(sz) << "]\n";
std::cout << str_hex << ": " << i_hex << '\n';
std::cout << str_bin << ": " << i_bin << '\n';
std::cout << str_auto << ": " << i_auto << '\n';
stof(s,p)例子
cout << "stof示例" << endl;
std::string orbits("686.97 365.24");
std::string::size_type sz; // alias of size_t
//1.mars = 686.97，sz保存空格下标
float mars = std::stof(orbits, &sz);
//1.将" 365.24"转换为float类型，earth = 686.97
float earth = std::stof(orbits.substr(sz));
std::cout << "One martian year takes " << (mars / earth) << " Earth years.\n";
以上就是string的常用操作使用说明
914
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
