参考：http://www.usidcbbs.com/read-htm-tid-1898.html
常见格式串
%% 印出百分比符号，不转换。
%c 整数转成对应的 ASCII 字元。
%d 整数转成十进位。
%f 倍精确度数字转成浮点数。
%o 整数转成八进位。
%s 整数转成字符串。
%x 整数转成小写十六进位。
%X 整数转成大写十六进位。
%n sscanf(str, "%d%n", &dig, &n)，%n表示一共转换了多少位的字符
sprintf函数
sprintf函数原型为 int sprintf(char *str, const char *format, ...)。作用是格式化字符串，具体功能如下所示：
（1）将数字变量转换为字符串。
（2）得到整型变量的16进制和8进制字符串。
（3）连接多个字符串。
int main(){
char str[256] = { 0 };
int data = 1024;
//将data转换为字符串
sprintf(str,"%d",data);
//获取data的十六进制
sprintf(str,"0x%X",data);
//获取data的八进制
sprintf(str,"0%o",data);
const char *s1 = "Hello";
const char *s2 = "World";
//连接字符串s1和s2
sprintf(str,"%s %s",s1,s2);
cout<<str<<endl;
return 0;
}
sscanf函数
sscanf函数原型为int sscanf(const char *str, const char *format, ...)。
将参数str的字符串根据参数format字符串来转换并格式化数据，转换后的结果存于对应的参数内。具体功能如下：
（1）根据格式从字符串中提取数据。如从字符串中取出整数、浮点数和字符串等。
（2）取指定长度的字符串
（3）取到指定字符为止的字符串
（4）取仅包含指定字符集的字符串
（5）取到指定字符集为止的字符串
当然，sscanf可以支持格式串"%[]"形式的，有兴趣的可以研究一下。
int main(){
char s[15] = "123.432,432";
int n;
double f1;
int f2;
sscanf(s, "%lf,%d%n", &f1, &f2, &n);
cout<<f1<<" "<<f2<<" "<<n;
return 0;
}
输出结果：123.432 432 11， 即一共转换了11位的字符。
stringstream类
<sstream>库定义了三种类：istringstream、ostringstream和stringstream，分别用来进行流的输入、输出和输入输出操作。
1. istringstream类： 用于执行C++风格的串流的输入操作。
2. ostringstream类：用于执行C风格的串流的输出操作。
3. strstream类： 同时可以支持C风格的串流的输入输出操作。stringstream s; s.str("");
istringstream类是从istream和stringstreambase派生而来，ostringstream是从ostream和 stringstreambase派生而来， stringstream则是从iostream类和stringstreambase派生而来。
istringstream是由一个string对象构造而来，istringstream类从一个string对象读取字符。
istringstream的构造函数原形如下： istringstream::istringstream(string str);
#include <iostream>
#include <sstream>
using namespace std;
int main()
{
istringstream istr;
istr.str("1 56.7");
//上述两个过程可以简单写成 istringstream istr("1 56.7");
cout << istr.str() << endl;
int a;
float b;
istr >> a;
cout << a << endl;
istr >> b;
cout << b << endl;
return 0;
}
上例中，构造字符串流的时候，空格会成为字符串参数的内部分界，例子中对a,b对象的输入"赋值"操作证明了这一点，字符串的空格成为了整型数据与浮点型数据的分解点，利用分界获取的方法我们事实上完成了字符串到整型对象与浮点型对象的拆分转换过程。
str()成员函数的使用可以让istringstream对象返回一个string字符串（例如本例中的输出操作(cout<<istr.str();）。
ostringstream同样是由一个string对象构造而来，ostringstream类向一个string插入字符。
ostringstream的构造函数原形如下： ostringstream::ostringstream(string str);
＃i nclude <iostream>
＃i nclude <sstream>
＃i nclude <string>
using namespace std;
int main()
{
ostringstream ostr;
//ostr.str("abc");//如果构造的时候设置了字符串参数,那么增长操作的时候不会从结 尾开始增加,而是修改原有数据,超出的部分增长
ostr.put('d');
ostr.put('e');
ostr<<"fg";
string gstr = ostr.str();
cout<<gstr;
system("pause");
}
在上例代码中，我们通过put()或者左移操作符可以不断向ostr插入单个字符或者是字符串，通过str()函数返回增长过后的完整字符串数据，但值 得注意的一点是，当构造的时候对象内已经存在字符串数据的时候，那么增长操作的时候不会从结尾开始增加,而是修改原有数据,超出的部分增长。
[ basic_stringbuf::str :
Sets or gets the text in a string buffer without changing the write position. ]
stringstream的构造函数原形如下：stringstream::stringstream(string str);
＃i nclude <iostream>
＃i nclude <sstream>
＃i nclude <string>
using namespace std;
int main()
{
stringstream ostr("ccc");
ostr.put('d');
ostr.put('e');
ostr<<"fg";
string gstr = ostr.str();
cout<<gstr<<endl;
char a;
ostr>>a;
cout<<a
system("pause");
}
//除此而外，stringstream类的对象我们还常用它进行string与各种内置类型数据之间的转换。 示例代码如下：
＃i nclude <iostream>
＃i nclude <sstream>
＃i nclude <string>
using namespace std;
int main()
{
stringstream sstr;
//--------int转string-----------
int a=100;
string str;
sstr<<a;
sstr>>str;
cout<<str<<endl;
//--------string转char[]--------
sstr.clear();//如果你想通过使用同一stringstream对象实现多种类型的转换，请注意在每一次转换之后都必须调用clear()成员函数。
string name = "colinguan";
char cname[200];
sstr<<name;
sstr>>cname;
cout<<cname;
system("pause");
}
实现任意类型的转换
template<typename out_type, typename in_value>
out_type convert(const in_value & t){
stringstream stream;
stream<<t;//向流中传值
out_type result;//这里存储转换结果
stream>>result;//向result中写入值
return result;
}
示例代码
#include <iostream>
#include <sstream>
using namespace std;
void test_stringstream_1(void)
{
string result="10000";
stringstream stream;
int n=0;
stream << result;
stream >> n; //n等于10000
cout << n << endl;
}
void test_stringstream_2()
{
string s;
stringstream ss;
int n, i, sum, a;
cin >> n;
getline(cin, s); // 读取换行
for (i=0; i<n; i++)
{
getline(cin, s);
ss.clear();
ss.str(s);
sum=0;
while (1)
{
ss >> a;
if ( ss.fail() ) break;
sum+=a;
}
cout << sum << endl;
}
}
template<typename T>
void to_string(string & result, const T& t)
{
/*
输入流、输出流 都是从内存的角度看的，
从内存出去叫 输入流，从来到内存叫输入流
数据从 内存 到 流 里面 是数据流出，
*/
ostringstream oss;//创建一个流
oss << t; //把值传递到流中
result = oss.str();//获取转换后的字符转并将其写入result
}
template<class out_type,class in_value>
out_type convert(const in_value & t)
{
stringstream stream;
stream<<t; //向流中传值
out_type result; //这里存储转换结果
stream>>result; //向result中写入值
return result;
}
int main(void)
{
test_stringstream_1();
test_stringstream_2();
string s1,s2,s3;
to_string(s1,10.5);//double到string
to_string(s2,123);//int到string
to_string(s3,true);//bool到string
cout<<s1<<endl<<s2<<endl<<s3<<endl;
double d;
string salary;
string s = "12.56";
d = convert<double>(s); //d等于12.56
salary = convert<string>(9000.0); //salary等于"9000"
cout << d <<endl<<salary<<endl;
std::stringstream stream_string;
std::string res;
int i = 1000;
stream_string << i; //将int输入流
stream_string >> res; //从stream中抽取前面插入的int值
std::cout << res << std::endl; // print the string "1000"
std::stringstream stream_char;
char chArray[8] ;
stream_char << 8888; //向stream中插入8888
stream_char >> chArray; //抽取stream中的值到result
std::cout << chArray << std::endl; // 屏幕显示 "8888"
/*
重复利用stringstream对象
如果你打算在多次转换中使用同一个stringstream对象，记住再每次转换前要使用clear()方法。
在多次转换中重复使用同一个stringstream（而不是每次都创建一个新的对象）对象最大的好处在于效率。
stringstream对象的构造和析构函数通常是非常耗费CPU时间的。
*/
std::stringstream stream;
int first, second;
stream<< "456"; //插入字符串
stream >> first; //转换成int
std::cout << first << std::endl;
/*
如果需要把格式化后的字符串通过>>输出到字符串, 必须每次都调用clear()方法!
所以, 保险期间, 每次缓冲区格式化后, 都通过clear(), str("") 两个函数都调用, 把stingstream类复位.
str() 和 str("") 的区别：str() 是返回内部缓冲区的一个copy, str("") 是清空内部缓冲区.
*/
stream.clear();//清除错误标志.在进行多次转换前，必须清除stream
stream.str("");//清除内容。stringstream类内部的缓冲区正确的清空方式。
stream << true; //插入bool值
stream >> second; //提取出int
std::cout << second << std::endl;
return 0;
}