<iomanip>里那堆操纵符（manipulator）本身不难用，难的是记住每一个的作用范围。std::setw只影响紧跟它的那一个输出项，std::fixed却会一直留在流的状态里，直到你显式改回去；std::setprecision(n)在默认模式下改的是有效数字位数，配上fixed才变成小数位数。这三个差异不知道，写出来的表格会歪、日志里的小数点会到处乱跑。这篇把操纵符按「作用范围」重新分一次类，再配一张对齐表格的完整程序和std::endl的实测代价。

1. 引子：第二列为什么全歪了

先看一段很多人写过一次的代码：想打印一张两列的清单，第一列左对齐、第二列右对齐，于是写了

std::cout<<std::setw(10)<<"apple"<<std::setw(8)<<10.5<<'\n';std::cout<<std::setw(10)<<"banana"<<std::setw(8)<<2.25<<'\n';

第一行看起来很对，第二行也对，但只要中间插了一个循环、或者把宽度设置挪到了循环外面，输出立刻塌掉。原因是std::setw不是流的状态，而是一次性的「参数」：它只对紧随其后的那一个输出项生效，用完立刻恢复成 0。而std::setfill、std::left、std::fixed这些是真正的流状态，会一直留着。混淆这两类，是 iostream 格式化最常见的翻车方式。

官方文档：std::setw、标准操纵符总览

2. 先把操纵符分成两类

这两类的行为差异，用一张图最直观：

操纵符的作用范围 +------------------------------------------------------------+ | 一次性：只影响紧跟的下一个输出项，然后自动失效 | | setw(n) | | -> 想给 n 个字段设宽度，就得写 n 次 setw(n) | +------------------------------------------------------------+ | 持久：写进了流的状态标志，之后每个输出项都受影响 | | 浮点格式 fixed / scientific / defaultfloat (floatfield)| | 精度 setprecision(n) (precision) | | 填充字符 setfill(c) | | 对齐 left / right / internal (adjustfield)| | 进制 hex / oct / dec / showbase (basefield)| | 布尔/符号 boolalpha / showpos / uppercase | +------------------------------------------------------------+ 一次输出表达式的求值顺序： cout << setw(8) << setfill('0') << 42 << 43 | | | | | | +-- 42 用宽度 8 填充 '0' | +-- 填充字符写进流状态，永久生效 +-- 宽度只对 42 生效；43 又回到宽度 0（但填充还是 '0'）

速查表按「是否持久」和「属于哪个头文件」列出来：

setiosflags/resetiosflags是同一批标志的另一种写法，写起来更啰嗦，但能一次性改一整组：

// 片段：setiosflags 就是「用位掩码设标志」，和直接写操纵符等价std::cout<<std::setiosflags(std::ios::fixed)<<std::setprecision(3)<<3.14159;std::cout<<std::resetiosflags(std::ios::floatfield)<<3.14159;// 等价于先 defaultfloat

3. setw 只吃一个输出项

第一个坑，写个小程序验证：

// iomanip_setw.cpp — 编译: g++ -std=c++17 -Wall -O2 iomanip_setw.cpp -o demo#include<iomanip>#include<iostream>intmain(){std::cout<<'['<<std::setw(8)<<42<<"]\n";std::cout<<'['<<42<<"]\n";// 宽度已经回到 0std::cout<<'['<<std::setw(8)<<42<<"]["<<std::setw(8)<<42<<"]\n";}

[ 42] [42] [ 42][ 42]

第二行是重点：流里没有留下任何「宽度 8」的记忆，所以每个要控制宽度的字段都得单独写一次std::setw。这也解释了为什么表格打印的循环体里，每次迭代都要重新std::setw。

4. 填充、对齐：这些是持久的

setfill一写就留下，left/right也是。下面这段把「一次性」和「持久」放在一起对比：

// iomanip_fill.cpp — 编译: g++ -std=c++17 -Wall -O2 iomanip_fill.cpp -o demo#include<iomanip>#include<iostream>intmain(){std::cout<<'['<<std::setfill('0')<<std::setw(6)<<42<<"]\n";std::cout<<'['<<std::setw(6)<<42<<"]\n";// 填充字符还是 '0'std::cout<<'['<<std::setfill(' ')<<std::setw(6)<<42<<"]\n";std::cout<<"left ["<<std::left<<std::setw(6)<<42<<"]\n";std::cout<<"right ["<<std::right<<std::setw(6)<<42<<"]\n";std::cout<<"left ["<<std::left<<std::setw(6)<<42<<"]\n";std::cout<<"internal ["<<std::internal<<std::showpos<<std::setw(6)<<-42<<"]\n";std::cout<<"default ["<<std::right<<std::noshowpos<<std::setw(6)<<-42<<"]\n";}

[000042] [000042] [ 42] left [42 ] right [ 42] left [42 ] internal [- 42] default [ -42]

前两行说明setfill('0')是持久的（第二行没再写它，仍然补 0）；后三行说明left也是持久的。internal的效果是把填充塞在符号和数值之间，- 42就是这个意思：排版带正负号的数字列时比统一右对齐更整齐。

5. setprecision：有效数字还是小数位

这是第二个坑，也是最容易算错的地方。std::setprecision(n)的语义取决于当前的浮点格式标志：

// iomanip_precision.cpp — 编译: g++ -std=c++17 -Wall -O2 iomanip_precision.cpp -o demo#include<iomanip>#include<iostream>intmain(){constexprdoublekPi=3.14159265358979;std::cout<<" default : "<<kPi<<'\n';std::cout<<"setprecision(5) : "<<std::setprecision(5)<<kPi<<'\n';std::cout<<"fixed + prec(5) : "<<std::fixed<<std::setprecision(5)<<kPi<<'\n';std::cout<<"sci + prec(3) : "<<std::scientific<<std::setprecision(3)<<kPi<<'\n';std::cout<<"defaultfloat : "<<std::defaultfloat<<std::setprecision(5)<<1.5<<'\n';std::cout<<"setprecision(9) : "<<std::setprecision(9)<<1.0/3.0<<'\n';}

default : 3.14159 setprecision(5) : 3.1416 fixed + prec(5) : 3.14159 sci + prec(3) : 3.142e+00 defaultfloat : 1.5 setprecision(9) : 0.333333333

对照着看：setprecision(5)先给出3.1416（五位有效数字，注意它进位了），换成fixed之后同一句setprecision(5)变成五位小数3.14159。最后一行还顺手说明默认模式不补尾零：1.5就是1.5，不会变成1.5000；想要固定小数位，只有fixed一条路。

官方文档：std::setprecision、std::fixed

6. fixed 是持久的，忘了复位就会污染后面的输出

真正会咬人的是fixed不会自己失效。下面这个程序演示「设完fixed就去干别的事」会发生什么：

// iomanip_fixed_leak.cpp — 编译: g++ -std=c++17 -Wall -O2 iomanip_fixed_leak.cpp -o demo#include<iomanip>#include<iostream>intmain(){std::cout<<std::fixed<<std::setprecision(2);std::cout<<"pi = "<<3.14159265<<'\n';std::cout<<"double = "<<2.0<<'\n';// 本来想输出 2std::cout<<"int = "<<7<<'\n';// 整数不受浮点标志影响std::cout<<std::defaultfloat<<std::setprecision(6);// 显式复位std::cout<<"pi = "<<3.14159265<<'\n';}

pi = 3.14 double = 2.00 int = 7 pi = 3.14159

2.0被格式化成2.00—— 这就是「忘记恢复」的后果。顺便注意int = 7：整数插入不走floatfield，所以不受影响，这也是为什么这个 bug 常常潜伏很久才被发现（只有浮点字段会变）。正确做法是在设置之前先存一下旧状态，或者干脆在格式化的地方用完立刻复位。用std::ostringstream做「局部格式化」是更省心的写法，因为流的生命周期就是格式化的生命周期：

官方文档：std::ostringstream

7. 进制、布尔、正号

同一批状态标志里还有进制和布尔显示，它们的持久性一模一样：

// iomanip_base.cpp — 编译: g++ -std=c++17 -Wall -O2 iomanip_base.cpp -o demo#include<iomanip>#include<iostream>intmain(){std::cout<<"dec 255 : "<<std::dec<<255<<'\n';std::cout<<"hex 255 : "<<std::hex<<255<<'\n';std::cout<<"hex 100 : "<<100<<'\n';// 还是 hex，输出 64std::cout<<"hex+showbase : "<<std::showbase<<100<<'\n';std::cout<<"oct+showbase : "<<std::oct<<255<<'\n';std::cout<<"dec 255 : "<<std::dec<<std::noshowbase<<255<<'\n';std::cout<<"bool 默认 : "<<true<<' '<<false<<'\n';std::cout<<"boolalpha : "<<std::boolalpha<<true<<' '<<false<<'\n';std::cout<<"showpos : "<<std::showpos<<42<<'\n';}

dec 255 : 255 hex 255 : ff hex 100 : 64 hex+showbase : 0x64 oct+showbase : 0377 dec 255 : 255 bool 默认 : 1 0 boolalpha : true false showpos : +42

第三行是关键：std::hex写了一次之后，后面所有整数都按十六进制打，100直接变成64。这也是网络协议调试代码里最常见的「莫名其妙打印出 ff」的来源。所以只要切换过进制，就该在离开那个作用域前写回std::dec。

8. std::endl 的代价：每次都是一次系统调用

Core Guidelines 的 SL.io.50 只有一句话：avoidendl。原因是std::endl等于'\n'加上一次flush()，而flush()会把缓冲区里的内容直接推进操作系统，也就是一次write系统调用。

// iomanip_flush.cpp — 编译: g++ -std=c++17 -Wall -O2 iomanip_flush.cpp -o demo#include<chrono>#include<cstdio>#include<fstream>#include<iostream>constexprconstchar*kSinkPath="miao_tmp_sink.txt";constexprintkLines=20000;usingClock=std::chrono::steady_clock;usingMs=std::chrono::duration<double,std::milli>;// 反例提示：不要在主循环里写 std::endl —— 它等价于 '\n' 再 flush，// 每一行都触发一次系统调用（Core Guidelines SL.io.50）Msrun(boolflush_every_line){std::ofstreamsink(kSinkPath,std::ios::out|std::ios::trunc);if(!sink){returnMs{0};}std::streambuf*constold=std::cout.rdbuf(sink.rdbuf());constautot0=Clock::now();for(inti=0;i<kLines;++i){std::cout<<"line "<<i<<'\n';if(flush_every_line){std::cout.flush();}}std::cout.flush();constautot1=Clock::now();std::cout.rdbuf(old);returnMs(t1-t0);}intmain(){constMs nl=run(false);constMs fl=run(true);std::cout<<"只写换行 : ~~ ms\n";std::cout<<"每行都刷 : ~~ ms\n";std::remove(kSinkPath);}

只写换行 : ~~ ms 每行都刷 : ~~ ms

实际测下来，「每行都刷」比「只写换行」慢一个数量级左右（这里每次输出都多一次系统调用）。所以：

什么时候真的需要刷？程序要崩溃了、用户按Ctrl+C前必须看到进度、或者多进程共享同一个终端时。除此之外，进程正常退出时 iostream 会自动刷缓冲，不需要手动来一下。

官方文档：C++ Core Guidelines · SL.io.50 Avoid endl、std::endl

9. 完整示例：打印一张对齐的账单表格

把前面所有点串起来。注意观察循环体里setw每次都要重写、而left/right只设一次：

// iomanip_table.cpp — 编译: g++ -std=c++17 -Wall -O2 iomanip_table.cpp -o demo#include<iomanip>#include<iostream>#include<string>#include<vector>structItem{std::string name;doubleprice=0.0;intqty=0;};intmain(){conststd::vector<Item>items{{"apple",10.5,3},{"banana",2.25,12},{"cherry",128.0,1},};std::cout<<std::left<<std::setw(10)<<"name"<<std::right<<std::setw(8)<<"price"<<std::setw(6)<<"qty"<<std::setw(12)<<"subtotal"<<'\n';std::cout<<std::string(36,'-')<<'\n';doubletotal=0.0;for(constItem&it:items){constdoublesub=it.price*static_cast<double>(it.qty);total+=sub;std::cout<<std::left<<std::setw(10)<<it.name// 名字左对齐<<std::right<<std::fixed<<std::setprecision(2)<<std::setw(8)<<it.price<<std::setw(6)<<it.qty<<std::setw(12)<<sub<<'\n';}std::cout<<std::string(36,'-')<<'\n';std::cout<<std::left<<std::setw(24)<<"total"<<std::right<<std::setw(12)<<total<<'\n';}

name price qty subtotal ------------------------------------ apple 10.50 3 31.50 banana 2.25 12 27.00 cherry 128.00 1 128.00 ------------------------------------ total 186.50

有两个可以再优化的点。一是不要依赖「上一次设过什么」：这张表里std::fixed和std::setprecision(2)只设了一次就一劳永逸，但如果函数中间插了三行别的输出，就得回头确认状态。工程代码里更稳的写法是把「格式化一个金额」抽成函数，用std::ostringstream局部完成：

// 片段：局部格式化，流的生死就是格式的生命周期，不可能污染调用方std::stringmoney(doublev){std::ostringstream oss;oss<<std::fixed<<std::setprecision(2)<<v;returnoss.str();}

二是列宽写死（10、8、6）属于魔法数字。真要紧的话把它们提到constexpr常量，或者干脆用std::string::size_type算一下最长的名字长度 —— 但在打印报表这种场景，固定列宽本身是需求，写死可以接受，重点是一处定义、一处修改。

10. 延伸阅读

• 标准操纵符总览 —— 一页看全所有manip，包括<iomanip>之外的flush/ends。
• std::setw —— 文档明确写着 “This value is not sticky”，这就是这篇第 3 节的权威依据。
• std::setprecision —— 语义随floatfield而变，值得逐字读一遍。
• C++ Core Guidelines · SL.io.50 —— 「避免endl」的出处，一句话省下几个数量级的 I/O 开销。
• std::basic_ostringstream —— 局部格式化的标准工具。

本知识库内的相关篇目：

• 《C++ stringstream 实用指南：分词解析、类型互转与 clear/str 的区别》 —— stringstream 是标准库里的「内存 IO」三件套
• 《C++ 文件读写实战：ofstream 默认清空文件、getline 与 ＞＞ 混用的坑》 —— ifstream / ofstream / fstream 的打开模式、状态位语义、RAII 自动关闭全
• 《printf 与 cout 的性能差异与混用陷阱：sync_with_stdio 到底是什么》 —— printf 与 cout 的性能差异与混用陷阱，同体系里最该一起看的另一篇。

11. 一句话总结

把操纵符分成「一次性的setw」和「持久的状态标志」两堆，记住setprecision的语义跟着fixed走、endl每次都刷缓冲，格式化的坑基本就踩完了。