C++ 从cstring函数向string类成员函数迁移
C字符串和string类互转
#include <iostream>
#include <string>
int main(void)
{
//C字符串 转 string类
const char *s1 = "hello";
std::string s2 = std::string(s1);
std::cout<<s2<<std::endl;
//string类 转 C字符串
std::string s3 = "world";
char *s4 = (char*) s3.data(); //或 .c_str()，C++11后两者完全等价
std::cout<<s4<<std::endl;
return 0;
}string、string.h、cstring、CString的区别与联系
⑴ string是C++标准库里面的string模板，也包含了C风格字符串操作的库函数，因此可以定义string类，使用时需声明namespace std。
⑵ string.h是C风格字符串操作的一个库函数，因此使用#include <string.h>时是不能定义string类的，使用时不需声明namespace std。
⑶ cstring是把string.h放到std中，它的功能和string.h一样，因为使用了std，所以使用时需要声明namespace std。
⑷ CString属于MFC的类，Visual C++中最常用的字符串类，继承自CSimpleStringT类，所以使用CString时要包含afx.h头文件。
string类和C字符串的简单对比
声明字串
string s;
char s[100];
字串长度
s.length() 或 s.size()
strlen(s)
首尾字符
s.front() 和 s.back() 或 s[0] 和 s[s.size()-1]
s[0] 和 s[strlen(s)-1]
字符引用
s[i] 或 s.at(i)
s[i]
读取一行
getline(cin, s);
gets(s);
字串赋值
s="ABCD";
strcpy(s, "ABCD");
字串连接
s=s+"ABCD"; 或 s+="ABCD";
strcat(s, "ABCD");
字串比较
s=="ABCD";
strcmp(s, "ABCD");
string类与C字符串对比，感觉前者操作比较直观， 另外还不用自己管理内存，长度几乎没有限制并且可以任意加长缩短。
字符串的最大长度
字符串char s[]，char*s 的长度受限于操作系统给应用程序分派的栈内存、堆内存的大小。关于C++内存分配详见文末转载的附录。
string类字符串占用内存是动态的，它的上限可以通过string::max_size()函数获得。32位系统约4G字节，64位系统约4E字节(1E = 1KP = 1MT = 1GG = 2^60)；甚至有些超大型服务器上是16E字节。不过实际上使用时最大长度也受限于计算机内存容量的，在内存可以承受的范围内，可以简单地认为string支持的字符串大小没有上限，或者上限大到几乎用不到。
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
string str;
cout<<str.max_size()<<endl; //4611686018427387897<--64位系统 ≈4G个1G字节
cout<<unsigned(-1)<<endl; //4294967295<--32位系统通常会等于这个值，=4G-1字节
return 0;
}提示： 打开网址 cpp.sh/8krms，点RUN查看运行结果。
cstring库函数和string类成员函数对比
strlen、strnlen
功能：串长度，从字符串的首字符起到第一个 '\0' 前的字符止的字符个数；如果仅声明没赋初值，结果是不定的，计数到 '\0' (不含)才会停止。
用法：size_t strlen(const char *s);
size_t strlen(const char *s, size_t n);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
size_t size=0;
const char* str="Hello,world!";
size=strlen(str);
cout<<"Size of the string is "<<size<<endl;
size_t n;
n=5;
size=strnlen(str,n);
cout<<"Size of the string is "<<size<<endl;
n=20;
size=strnlen(str,n);
cout<<"Size of the string is "<<size<<endl;
//strnlen 计数到n或遇到'\0'止
//返回值：size=(n>=strlen(str))?strlen(str):n
return 0;
}提示： 打开网址 cpp.sh/6b6hj，点RUN查看运行结果。
string::size、string::length 串长
#include <iostream>
#include <string>
using namespace std;
int main ()
{
string str="Hello,world!";
cout<<str.size()<<endl;
cout<<str.length()<<endl;
//size() length() 两者完全等价
return 0;
}提示： 打开网址 cpp.sh/3nm3z，点RUN查看运行结果。
strcpy、strncpy
功能：串复制，将源字符串src全部、或最多n个字符复制到目标字符数组dest中，返回指向dest的指针。
用法：char *strcpy(char *dest, char *source);
char *strncpy(char *dest, char *src, size_t n);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
const char *str1="123456789";
char deststring[20]; //目标字符串数组长度得足够容纳源字符串
strcpy(deststring,str1); //全部复制
cout<<deststring<<endl; //结果为 123456789
const char *str2="hello,world!";
strncpy(deststring,str2,5); //部分复制5个字符，注意没得到'\0'
cout<<deststring<<endl; //结果为 hello6789
cout<<strlen(deststring)<<endl;
deststring[5]='\0'; //设置字符串结束标志
cout<<deststring<<endl; //结果为 hello
cout<<strlen(deststring)<<endl;
return 0;
}提示： 打开网址 cpp.sh/5yiqo，点RUN查看运行结果。
string::string、string::assign(string::operator=) 构造与赋值
#include <iostream>
#include <string>
#include <array>
#include <vector>
using namespace std;
int main ()
{
string dest,dest2;
string src="Hello,world!";
dest.assign(src); //对比strcpy
cout<<dest<<endl;
dest2=src; //或直接用=赋值
cout<<dest2<<endl;
int n=5;
dest=string(src.begin(),src.begin()+n); //对比strncpy
cout<<dest<<endl;
char buf[20]="Hello,world!";
dest=string(buf,buf+n); //从字符数组取值
cout<<dest<<endl;
n=2;
array<char,5>arr={'H','e','l','l','o'};
dest=string(arr.begin(),arr.begin()+n); //从array模板类取值
cout<<dest<<endl;
vector<char>vct={'H','e','l','l','o'};
dest=string(vct.begin(),vct.begin()+n); //从vector容器取值
cout<<dest<<endl;
//string类的本质和字符型vector或字符array类比较类同
return 0;
}提示： 打开网址 cpp.sh/6klz7，点RUN查看运行结果。
strset、strnset
功能：置字符，将字符串str中全部或部分前n个字符设置为字符c，返回指向dest的指针。
用法：char *strcat(char *str, char c);
char *strncat(char *str, char c, size_t n);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char str[]="Hello,world!";
char c='*';
char *p;
p=strnset(str,c,5);
cout<<p<<endl; //显示：*****,world!
cout<<str<<endl; //显示：*****,world!
p=strset(str,c);
cout<<p<<endl; //显示：************
cout<<str<<endl; //显示：************
return 0;
}提示： 某些编译器已废止弃用这两个函数。
string::replace+string::string or string::assign+string::substr
无对应函数，可以用多种函数组合的方法实现类似功能。
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
char c='*';
string str="Hello,world!";
str=str.replace(0,5,string(5,c));
cout<<str<<endl;
str="Hello,world!";
str=str.replace(str.begin(),str.begin()+5,string(5,c));
cout<<str<<endl;
//也能用其他函数组合实现：
str="Hello,world!";
str=str.assign(5,c)+str.substr(5,str.size());
cout<<str<<endl;
str="Hello,world!";
str=string(5,c)+str.substr(5,str.size());
cout<<str<<endl;
return 0;
}提示： 打开网址 cpp.sh/3ez23，点RUN查看运行结果。
strcat、strncat
功能：串连接，把源串src的全部或前n个字符接到目标串dest尾，返回指向dest的指针。
用法：char *strcat(char *dest, char *src);
char *strncat(char *dest, char *src, size_t n);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char dest[8];
const char *Dev="Dev-",*CPP="C++";
char *str;
strcpy(dest,Dev);
cout<<dest<<endl;
str=strcat(dest,CPP);
cout<<dest<<endl;
cout<<str<<endl;
return 0;
}提示： 打开网址 cpp.sh/2mddy，点RUN查看运行结果。
std::operator+ 字符串连接
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
string cpp,hello="Hello,",Dev="Dev-",c="C++";
cpp=hello+Dev+c; //直接用加号连接
cout<<cpp<<endl;
int n=5;
Dev+=c; //还能用 +=
cpp=hello+string(Dev.begin(),Dev.begin()+n); //对比 strncat()
cout<<cpp<<endl;
return 0;
}提示： 打开网址 cpp.sh/7oumk，点RUN查看运行结果。
strcmp、strncmp
功能：串比较，从索引0位置开始比Ascii码，若str1>str2，返回值 > 0；反之 < 0；两串相等，返回0。
用法：int strcmp(char *str1, char *str2);
int strncmp(char *str1, char *str2, size_t n);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
const char *buf1="aaa", *buf2="bbb", *buf3="ccc";
int ptr;
ptr=strcmp(buf2,buf1);
if(ptr>0)
cout<<"buf2 is greater than buf1"<<endl;
else
cout<<"buf2 is less than buf1"<<endl;
ptr=strcmp(buf2,buf3);
if(ptr>0)
cout<<"buf2 is greater than buf3"<<endl;
else
cout<<"buf2 is less than buf3"<<endl;
return 0;
}提示： 打开网址 cpp.sh/37okg，点RUN查看运行结果。
string::compare、std::operator== (>、<、>=、<=) 字符串比较
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
string str1="abc";
string str2="aba";
string str3="abc";
cout << str1.compare(str2) <<endl; //1
cout << str1.compare(str3) <<endl; //0
cout << (str1==str2) <<endl; //0
cout << (str1>str2) <<endl; //1
cout << (str1<str2) <<endl; //0
cout << (str1>=str2) <<endl; //1
cout << (str1<=str2) <<endl<<endl; //0
cout << (str1==str3) <<endl; //1
cout << (str1>str3) <<endl; //0
cout << (str1<str3) <<endl; //0
cout << (str1>=str3) <<endl; //1
cout << (str1<=str3) <<endl; //1
return 0;
}提示： 打开网址 cpp.sh/62ifh，点RUN查看运行结果。compare()在网页版上的返回值稍有不同。
strlwr、strupr
功能：串大小写，字符串的字母转化为小写字母或大写字母，字母之外的标点和数字不变。
用法：char *strlor(char *str); //字串中的字母都 tolower(c)
char *strupr(char *str); //字串中的字母都 toupper(c)
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char buf[]="Dev-C++ 5.11";
cout<<strlwr(buf)<<endl; //显示：dev-c++ 5.11
cout<<strupr(buf)<<endl; //显示：DEV-C++ 5.11
return 0;
}提示： 某些编译器已废止弃用这两个函数。
transform(s.begin(), s.end(), s.begin(), ::tolower); 、::toupper
无对应函数，用transform算法把全串字符逐个转小写或大写。需要#include<algorithm>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(void)
{
string t;
cout << "请输入字符串：";
cin >> t;
transform(t.begin(),t.end(),t.begin(),::tolower); //转小写
cout<<"转换成小写之后：" << t << endl;
transform(t.begin(),t.end(),t.begin(),::toupper); //转大写
cout<<"转换成大写之后：" << t << endl;
return 0;
}提示： 打开网址 cpp.sh/8zs4o，点RUN查看运行结果。
stricmp\strcmpi、strnicmp
功能：串比较，以大小写不敏感方式比较。
用法：int stricmp(char *str1, char *str2); 也可写成strcmpi() 其宏定义
int strnicmp(char *str1, char *str2, size_t n);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
int ptr;
const char *buf1="BBB", *buf2="bbb";
ptr=stricmp(buf2,buf1);
if(ptr>0)
cout<<"buf2 is greater than buf1"<<endl;
else if(ptr<0)
cout<<"buf2 is less than buf1"<<endl;
else if(ptr==0)
cout<<"buf2 equals buf1"<<endl;
return 0;
}注：无对应函数，先把两个字串同转大写或小写再进行比较。
strchr、strrchr
功能：查找指定字符在串中首次出现的位置，返回一个指向str中指定字符首次出现的指针，如找不到则返回一个空指针。前者为从左到右正方向查找，后者为从右向左反方向查找。
用法：char *strchr(char *str, char c);
char *strrchr(char *str, char c);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char str[20];
char c='s';
strcpy(str,"It\'s a string"); //位置索引从0开始，3即是第4个字符
char *p=strchr(str,c);
if(p) //p-str==3 指针减法运算
cout<<"The character "<<c<<" is at position："<<p-str<<endl;
else
cout<<"The character was not found!"<<endl;
cout<<p<<endl; //指针已移位，显示为：s a string
char *q=strrchr(str,c); //反向查找，位置索引还是从0开始，7即是第8个字符
if(q) //q-str==7 指针减法运算
cout<<"The character "<<c<<" is at position："<<q-str<<endl;
else
cout<<"The character was not found!"<<endl;
cout<<q<<endl; //指针已移位，显示为：string
return 0;
}提示： 打开网址 cpp.sh/4m2on，点RUN查看运行结果。
strstr
功能：查找子串，指定子串在字符串中首次出现的位置。返回一个指向str中首次出现substr的指针，如找不到则返回一个空指针。
用法：char *strstr(char *str, char *substr);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char str[20];
char s[4]="str";
strcpy(str,"It\'s a string"); //位置索引从0开始，7即是第8个字符开始
char *p=strstr(str,s);
if(p) //p-str==7 指针减法运算
cout<<"The substring "<<s<<" is at position："<<p-str<<endl;
else
cout<<"The substring was not found!"<<endl;
cout<<p<<endl; //指针已移位，显示为：string
return 0;
}提示： 打开网址 cpp.sh/4tkva ，点RUN查看运行结果。
string::find、string::rfind 查找字符或子串
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
string str="It\'s a string.";
char c='s';
string::size_type pos; //或声明为 size_t pos; 如串长不是巨大的话可用int代替
//C++函数重载，查找字符或子串用同一函数名
pos=str.find(c); //显示：3 正向查找，类似于strchr(str,c)
cout<<pos<<endl;
pos=str.rfind(c); //显示：7 反向查找，类似于strrchr(str,c)
cout<<pos<<endl;
string substr="string";
pos=str.find(substr); //显示：7
cout<<pos<<endl;
pos=str.rfind(substr); //显示：7
cout<<pos<<endl;
//另可以指定查找位置，返回的还在全串的位置
pos=str.find(substr,5); //显示：7
cout<<pos<<endl;
pos=str.find(substr,8); //没找到则返回一个很大的数=Maximum value for size_t
//(实际上就是成员常量string::npos) 声明int型则返回-1
cout<<pos<<endl;
// string::npos 的用法：
if (pos != string::npos) //string::npos 可以用 str.npos 替代
cout << "position is：" << pos << endl;
else
cout << "Not found the substring：" + substr; //此处没找到的原因，设置了开始位置 8
return 0;
}提示： 打开网址 cpp.sh/6skc7，点RUN查看运行结果。
strspn、strcspn
功能：查找前缀，计算字符串str中从头开始连续有几个字符都 [属于/不属于] 字符串control。前者返回第一次失配前匹配的字符数，后者返回第一次匹配前失配的字符数。
用法：size_t strspn (const char *str, const char *control);
size_t strcspn (const char *str, const char *control);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
const char *str="(3+3/7)*7 or (4-4/7)*7 = 24";
cout<<strspn(str,"()")<<endl; //返回1，str前部连续的有1个字符匹配，即数字3之前的字符数
cout<<strspn(str,"37()+-*/")<<endl; //返回9，str前部连续有9个字符匹配，即空格前的字符数
cout<<strspn(str,"1234567890")<<endl<<endl; //返回0，字符串str非数字起始
cout<<strcspn(str," ")<<endl; //返回9，str前部9个字符未出现空格
cout<<strcspn(str,"+-*/")<<endl; //返回2，str前部2个字符未出现+-*/
cout<<strcspn(str,"1234567890")<<endl; //返回1，即第1个字符不是数字
return 0;
}提示： 打开网址 cpp.sh/34vlm，点RUN查看运行结果。
string::find_first_of、string::find_first_not_of
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
size_t index,last=0;
string s="(3+3/7)*7 or (4-4/7)*7 = 24";
string separator="37()+-*/";
index=s.find_first_of(separator,last);
while (index==last++)
index=s.find_first_of(separator,last);
cout<<"第一次失配前已匹配的字符数："<<last-1<<endl; //显示9，即最后一个匹配的位置索引+1
last=0;
separator="or";
do index=s.find_first_not_of(separator,last++); //注意：do-while和while-do的区别
while (index==last-1);
cout<<"第一次匹配前已失配的字符数："<<last-1<<endl; //显示10，即最后一个失配的位置索引+1
return 0;
}提示： 打开网址 cpp.sh/4fi7x，点RUN查看运行结果。
strpbrk
功能：查找字符集，查找breakset里任一字符第一次出现在dest里的位置，返回dest中第一次出现breakset中字符的指针，如果不存在返回NULL。
用法：char *strpbrk(const char *dest, const char *breakset);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
const char *str="24 = (3+3/7)*7 or (4-4/7)*7";
const char *breakset="()^%"; //分界符中至少有一个字符属于str，否则返回NULL
str=strpbrk(str,breakset); //左(最先出现，此时str=="(3+3/7)*7 or (4-4/7)*7"
if (str) cout<<str<<endl; //cout输出NULL，程序会异常退出
//用do-while计算除分界符之外的字符数
unsigned int cnt=0;
const char *separator="()+-*/ or";
do {
str=strpbrk(str,separator);
if (str==NULL) break; //找不到了就中断循环，否则以下操作会退出
cout<<cnt<<":"<<str<<endl; //本行测试用，可去掉
str+=strspn(str,separator);
++cnt;
} while(str && *str);
//cout<<str; //此时str==NULL，此处显示str就会中止退出
cout<<"\nThere are "<<cnt<<" digits."<<endl;
return 0;
}提示： 打开网址 cpp.sh/9tgqj，点RUN查看运行结果。
string::find + string::substr
无对应函数，以上两个函数组合可以模拟strpbrk例程的效果。
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
string str="(3+3/7)*7 or (4-4/7)*7";
string sep="()+-*/ or";
int index=0,cnt=0;
for(auto s:str){
if (sep.find(s)==string::npos)
cout<<cnt++<<":"<<str.substr(index-1,str.size())<<endl;
index++;
}
//cout<<str; //此时str还是原值，string类的优点之一
cout<<"\nThere are "<<cnt<<" digits."<<endl;
return 0;
}提示： 打开网址 cpp.sh/2iuoy，点RUN查看运行结果。
strtok、(strtok_r、strtok_s)
功能：串分割，把字符串中用分界符分割成多个子串。saveptr记录的是每次被分割后剩余的部分。
用法：char *strtok(char *s, const char *delim);
char *strtok_r(char *str, const char *delim, char **saveptr); //linux版本
char *strtok_s(char *strToken, const char *strDelimit, char **buf); //windows版本
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
int main(void)
{
const char *tmp = "hello,Dev-C++";
char str[20];
strcpy(str,tmp);
cout<<"str初值："<<str<<endl;
char *token = strtok(str,",");
cout<<token<<endl;
token=strtok(NULL,","); //str必须包含分界符，否则此行出错
cout<<token<< endl;
cout<<"str终值："<<str<<endl; //str被改变了！
//strtok(str,delim)允许同时有多个分界符，但delim中至少有一个字符是str的子串
cout<<"\n多个子串可用while循环来分隔"<<endl;
strcpy(str,tmp); //重新取值
token=strtok(str,",-");
while(token!=NULL){
cout<<token<<endl;
token=strtok(NULL,",-");
}
cout<<"\n把分割出来的子串装入容器中"<<endl;
strcpy(str,tmp); //重新取值
vector<string>vect;
token=strtok(str,",-");
while(token!=NULL){
vect.push_back(token);
token=strtok(NULL,",-");
}
for (auto v:vect) cout<<v<<endl;
return 0;
}提示： 打开网址 cpp.sh/5fa2d，点RUN查看运行结果。
string::find_first_of + string::substr 串分割
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(void)
{
vector<string>vect;
size_t index,last=0;
string s="Hello,Dev-C++";
string delim=",-";
index=s.find_first_of(delim,last);
while (index!=s.npos){
vect.push_back(s.substr(last,index-last));
last=index+1;
index=s.find_first_of(delim,last);
}
if (s.length()-last>0)
vect.push_back(s.substr(last));
for(auto v:vect) cout<<v<<endl;
return 0;
}提示： 打开网址 cpp.sh/92cka，点RUN查看运行结果。
strrev
功能：串倒序，所有字符反转顺序。
用法：char *strrev(char *str);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char str[15];
strcpy(str,"Hello,world!");
cout<<str<<endl;
char *p=strrev(str);
cout<<p<<endl; //显示： !dlrow,olleH
return 0;
}提示： 某些编译器已废止弃用这个函数。
std::reverse(string::begin, string::end) 串倒序
或 string::assign(string::rbegin, string::rend)
用reverse算法全串倒序，需要#include<algorithm>；或用assign()函数反向赋值。
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
using namespace std;
int main(void)
{
string str="Hello,world!";
reverse(str.begin(),str.end()); //必须包括<algorithm>头文件
cout<<str<<endl; //显示： !dlrow,olleH
//或用string::assign + string::rbegin rend
str.assign(str.rbegin(),str.rend());
cout<<str<<endl; //显示： Hello,world!
//reverse()算法也适用于C字符串、字符数组
char *c=(char*)str.c_str();
reverse(c,c+strlen(c));
cout<<c<<endl; //显示： !dlrow,olleH
char s[20];
strcpy(s,c);
reverse(s,s+strlen(s));
cout<<s<<endl; //显示： Hello,world!
return 0;
}提示： 打开网址 cpp.sh/6vzuk ，点RUN查看运行结果。
swab
功能：交换字节，奇偶数位置的字符相互交换位置，nbytes通常要求是偶数。
用法：void swab (char *from, char *to, int nbytes);
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char source[11]="1234567890";
char target[11];
swab(source,target,strlen(source));
cout<<source<<" | "<<target<<endl; //显示：1234567890 | 2143658709
return 0;
}string::swap
无对应函数，有个string::swap(string str1,string str2)函数，但它的功能是交换两个字符串的值。
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
string source="1234567890";
string target;
target.swap(source);
cout<<source<<" | "<<target<<endl;
return 0;
}string Swab(string str);
自定义函数模拟实现swab()
#include<iostream>
#include<string>
using namespace std;
string Swab(string);
int main(void)
{
string str="1234567890";
cout<<str<<" | "<<Swab(str)<<endl;
return 0;
}
string Swab(string str)
{
int i,j=0;
for (auto&s:str){
if (j%2==1){
i=str.at(j-1);
str.at(j-1)=s;
s=i;
}
j++;
}
return str;
}提示： 打开网址 cpp.sh/8giax，点RUN查看运行结果。
strtol、strtod、strtoul
功能：字符串转整数或浮点数，转换前会跳过空格字符，如有不合条件的字符由endptr传回。非<cstring>库函数，包含在头文件 <cstdlib> 或 <stdlib.h>
用法：long strtol(char *str, char **endptr, int base); //base为整数的进制基数，十进制base==10
double strtod(char *str, char **endptr); //转浮点数，可以转换的字符有+-Ee.及数字
unsigned long strtoul(const char *nptr,char **endptr,int base); //转无符号长整型
#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
char *endptr;
char a[] = "123.4567890";
char b[] = "123.456Hann";
char c[] = "-123.456E-7";
cout<<strtol(a,NULL,10)<<endl;
cout<<a<<endl<<endl;
cout<<strtol(a,&endptr,10)<<endl;
cout<<a<<endl; //a未被改变
cout<<endptr<<endl<<endl;
cout<<strtod(b,&endptr)<<endl;
cout<<b<<endl; //b未被改变
cout<<endptr<<endl<<endl;
cout<<strtod(c,NULL)<<endl;
}提示： 打开网址 cpp.sh/94bjb，点RUN查看运行结果。
用stringstream类转数字
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
template<typename _Type>
_Type str2number(string s)
{
_Type num;
stringstream ss;
ss<<s;
ss>>num;
ss.clear();
return num;
}
int main(void)
{
string str="1234.56789e-5";
long double a;
long int b;
double c;
int d;
a=str2number<long double>(str);
b=str2number<long int>(str);
c=str2number<double>(str);
d=str2number<int>(str);
cout<<a<<endl;
cout<<b<<endl;
cout<<c<<endl;
cout<<d<<endl;
return 0;
}提示： 打开网址 cpp.sh/6s6as，点RUN查看运行结果。
以上代码均在Dev-C++ 5.11上通过无错编译，其他字符串相关文章请阅《C++ ＜cstring＞字符串库函数的自定义实现》
附录：
【转载】C++内存分配方式详解——堆、栈、自由存储区、全局/静态存储区和常量存储区
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。里面的变量通常是局部变量、函数参数等。在一个进程中，位于用户虚拟地址空间顶部的是用户栈，编译器用它来实现函数的调用。和堆一样，用户栈在程序执行期间可以动态地扩展和收缩。
堆，就是那些由 new 分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个 new 就要对应一个 delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。堆可以动态地扩展和收缩。
自由存储区，就是那些由 malloc 等分配的内存块，他和堆是十分相似的，不过它是用 free 来结束自己的生命的。
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的 C 语言中，全局变量又分为初始化的和未初始化的（初始化的全局变量和静态变量在一块区域，未初始化的全局变量与静态变量在相邻的另一块区域，同时未被初始化的对象存储区可以通过 void* 来访问和操纵，程序结束后由系统自行释放），在 C++ 里面没有这个区分了，他们共同占用同一块内存区。
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）
明确区分堆与栈
在 BBS 上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子： void f() { int* p=newint[5]; }
这条短短的一句话就包含了堆与栈，看到 new，我们首先就应该想到，我们分配了一块堆内存，那么指针 p 呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针 p。在程序会先确定在堆中分配内存的大小，然后调用 operator new 分配内存，然后返回这块内存的首地址，放入栈中，他在 VC6 下的汇编代码如下：
00401028push 14h
0040102Acall operator new (00401060)
0040102Fadd esp,4
00401032mov dword ptr [ebp-8],eax
00401035mov eax,dword ptr [ebp-8]
00401038mov dword ptr [ebp-4],eax这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是 delete p 么？噢，错了，应该是 delete []p，这是为了告诉编译器：我删除的是一个数组，VC6 就会根据相应的 Cookie 信息去进行释放内存的工作。
好了，我们回到我们的主题：堆和栈究竟有什么区别？
主要的区别由以下几点：
1、管理方式不同；
2、空间大小不同；
3、能否产生碎片不同；
4、生长方向不同；
5、分配方式不同；
6、分配效率不同；管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
空间大小：一般来讲在 32 位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在 Category 中选中 Output，然后在 Reserve 中设定堆栈的最大值和 commit。注意：reserve 最小值为 4Byte；commit 是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
碎片问题：对于堆来讲，频繁的 new/delete 势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。
生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由 malloc 函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是 C/C++ 函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
从这里我们可以看到，堆和栈相比，由于大量 new/delete 的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP 和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候 debug 可是相当困难的 ：）
对了，还有一件事，如果有人把堆栈合起来说，那它的意思是栈，可不是堆，呵呵，清楚了？
static 用来控制变量的存储方式和可见性
函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？ 最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此 函数控制）。需要一个数据对象为整个类而非某个对象服务，同时又力求不破坏类的封装性，即要求此成员隐藏在类的内部，对外不可见。
static 的内部机制：
静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。这样，它的空间分配有三个可能的地方，一是作为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的 main(）函数前的全局数据声明和定义处。
静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，所以在类声明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。
static 被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。
static 的优势：
可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的 值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。引用静态数据成员时，采用如下格式：
<类名>::<静态成员名>
如果静态数据成员的访问权限允许的话(即 public 的成员)，可在程序中，按上述格式来引用静态数据成员。
Ps：
(1) 类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致了它仅能访问类的静态数据和静态成员函数。
(2) 不能将静态成员函数定义为虚函数。
(3) 由于静态成员声明于类中，操作于其外，所以对其取地址操作，就多少有些特殊，变量地址是指向其数据类型的指针，函数地址类型是一个“nonmember 函数指针”。
(4) 由于静态成员函数没有 this 指针，所以就差不多等同于 nonmember 函数，结果就产生了一个意想不到的好处：成为一个 callback 函数，使得我们得以将 c++ 和 c-based x window 系统结合，同时也成功的应用于线程函数身上。
(5) static 并没有增加程序的时空开销，相反她还缩短了子类对父类静态成员的访问时间，节省了子类的内存空间。
(6) 静态数据成员在<定义或说明>时前面加关键字 static。
(7) 静态数据成员是静态存储的，所以必须对它进行初始化。
(8) 静态成员初始化与一般数据成员初始化不同：
初始化在类体外进行，而前面不加 static，以免与一般静态变量或对象相混淆；
初始化时不加该成员的访问权限控制符 private、public；
初始化时使用作用域运算符来标明它所属类；
所以我们得出静态数据成员初始化的格式： <数据类型><类名>::<静态数据成员名>=<值>
(9) 为了防止父类的影响，可以在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点需要注意：我们说静态成员为父类和子类共享，但我们有重复定义了静态成员，这会不会引起错误呢？不会，我们的编译器采用了一种绝妙的手法：name-mangling 用以生成唯一的标志。附录内容转自http://www.cnblogs.com/daocaoren/archive/2011/06/29/2092957.html