在C++里，我们使用cout进行控制台文本输出。这在学习编程的阶段很常用，但在真实的工作场合却极少使用，毕竟大部分的应用程序都是基于图形界面，而不是终端的。甚至，在C/C++的某些应用场合，比如单片机编程里，嵌入式设备甚至连屏幕都没有。

考虑到部分OJ系统中的在线编程题可能对输出格式作出精细要求，这里我们对cout控制输出进行“详细”讨论：包括cout的基本工作原理，以及通过cout进行精细格式输出的方法。

对工作原理不感兴趣，只想快速知道HOW的有编程经验的读者请直接阅读本文的第6部分。

1. cout基本工作原理

下述代码可以帮助我们理解通过cout的插入操作符(insertion operator<<)进行控制台文本输出的基本原理。

1
2
3
4
5
6
7
8
9
//Project - COUT
#include <iostream>
using namespace std;

int main() {
    cout << "pi = " << 3.14159 << endl;
    operator<<(cout,"pi = ").operator<<(3.14159).operator<<(endl);
    return 0;
}

上述代码的执行结果为：

1
2
pi = 3.14159
pi = 3.14159

在iostream头文件中，很容易找到cout的定义。cout是一个类型为ostream的对象，其被连接到了标准输出流，即控制台。

1
extern ostream cout;		/// Linked to standard output

上述程序的第6行与第7行完全等价。相关代码的执行过程如下：

  • cout << “pi = “的实质是执行了一个名为operator<<( )的函数，其中，第1个参数是cout对象，第2个参数是”pi = “。这个函数把第2个参数的字符串输出到第1个参数所代表的控制台中。同时，该函数返回了cout的引用作为函数执行的结果。

  • … << 3.141519则以前述函数调用所返回的cout引用作为基础，执行其成员函数operator<<( )。该成员函数存在多个函数名重载的版本，其中一个版本接受一个double作为参数，并将double的值输出到cout。同样地，本次函数调用也返回了cout的引用作为结果。

  • 类似地，… << endl同样对应cout.operator<<( )函数的一次执行，该成员函数的一个重载版本接受endl作为参数，并向cout所代表的控制台输出一个换行符。

<<操作符在C语言里用作左移位操作，C++的标准模板库通过定义与该操作符“同名”的函数，扩展了该操作符的功能：向cout输出对象内容。

总结：iostream定义了多个重载的operator<<()操作符函数，这些不同版本的函数接受不同类型的参数，包括int, char, float, double, const char*, string等，并将这些参数对象转换成字符串，并输出到控制台屏幕上。

2. 改变进制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//Project - HexOct
#include <iostream>
#include <stdio.h>
using namespace std;

int main(){
    int b = 0x17;          //十六进制 hexadecimal
    int c = 017;           //八进制   octal
    int d = 0b01111110;    //二进制   binary

    cout << "0x17 = " << b << ", 017 = " << c << ", 0b01111110 = " << d << endl;
    printf("17: %x, %d, %o\n", 17, 17, 17);
    cout << "17: " << hex << 17 << ", " << dec << 17 << ", " << oct << 17 << endl;

    hex(cout);
    cout << "17: " << 17 << ", ";
    dec(cout);
    cout << 17 << ", ";
    oct(cout);
    cout << 17 << endl;

    return 0;
}

上述代码的执行结果为：

1
2
3
4
0x17 = 23, 017 = 15, 0b01111110 = 126
17: 11, 17, 21
17: 11, 17, 21
17: 11, 17, 21

上述代码可以看出，通过执行cout << hex，可以改变cout的内部状态，使用在后续输出数值时使用16进制。cout << dec (十进制)，cout << oct (八进制)同理。

事实上，这里的hex, dec, oct是一种被称之为操作算子（manipulator）的特殊函数。下述3行代码事实上等价：

1
2
3
cout << hex;
cout.operator<<(hex);
hex(cout);

在ios_base.h中我们可以找到hex()函数的定义：

1
2
3
4
5
6
inline ios_base&
hex(ios_base& __base)
{
  __base.setf(ios_base::hex, ios_base::basefield);
  return __base;
}

在形式上，cout << hex被解释成多轮函数调用，首先是：

1
cout.operator<<(hex);

这个被重载的operator<<()函数将hex函数名当成一个函数指针，然后通过这个函数指针调用hex()函数：

1
hex(cout);

而hex()函数又通过cout的setf()函数发挥作用。读者或许会疑惑说，这么多层的函数调用是否会降低代码的执行效率，事实上，由于相关函数多是内联(inline)的，编译器的优化会消除这些“形式”上的不必要的函数调用。

3. 输出宽度控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <cmath>
using namespace std;

int main(){
    cout << "12345678901234567890" << endl;
    cout << "--------------------" << endl;

    cout.width(5);
    cout << "N";
    cout.width(15);
    cout << "2**N" << endl;
    cout << "--------------------" << endl;

    for (auto n=0;n<=10;n++){
        cout.width(5);
        cout << n;
        cout.width(15);
        cout << pow(2,n) << endl;
    }

    return 0;
}

上述代码的执行结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
12345678901234567890
--------------------
    N           2**N
--------------------
    0              1
    1              2
    2              4
    3              8
    4             16
    5             32
    6             64
    7            128
    8            256
    9            512
   10           1024

cout的成员函数width( )可以设定下一个输出项的宽度，但其作用范围仅限后一个输出项。当输出项的实际宽度小于设定宽度时，其左侧以空格填充。可以看到，上述程序借助于width( ）函数，输出了一个严格右对齐的表格，第一列的宽度为5，第2列的宽度为15。

通过fill( )成员函数，可以修改填充字符。请参见下述程序及其执行结果。

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
using namespace std;

int main(){
    cout.fill('*');  //修改填充字符为*
    cout.width(5);
    cout << "idx";
    cout.width(15);
    cout << "content";
    return 0;
}

上述程序的执行结果为：

1
**idx********content

4. 浮点数的输出格式

通过cout的precision( )函数可以设置其输出浮点数时的精度。见下述代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
using namespace std;

int main(){
    float v1 = 17.90f;
    float v2 = 3.1415926535798932f;
    cout << "before .precision(2)" << endl;
    cout << "v1 = " << v1 << endl;
    cout << "v2 = " << v2 << endl;

    cout.precision(2);
    cout << "after .precision(2)" << endl;
    cout << "v1 = " << v1 << endl;
    cout << "v2 = " << v2 << endl;

    return 0;
}

执行结果为：

1
2
3
4
5
6
before .precision(2)
v1 = 17.9
v2 = 3.14159
after .precision(2)
v1 = 18
v2 = 3.1

上述执行结果与我们的期望有很大不同。

在默认情况下，cout输出浮点数的精度为6，且这个精度并不是指小数点后的位数，而是所有的位数。cout会借助于四舍五入的方法输出指定“精度”的字符串，同时会舍弃末尾多余的0。

执行结果的第2行显示，17.90被舍弃掉末尾的0，输出为17.9。

执行结果的第3行显示，3.1415926535798932被四舍五入为3.14159，正好6位数字。

接下来，cout.precision(2)设定浮点数输出精度为2，此时，17.90被四舍五入输出为18，3.1415926535798932被四舍五入输出为3.1，都是两位数字。

如果期望cout输出的浮点数的位数确定，当位数不足时用0补齐，可以执行cout.setf(ios_base::showpoint)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;

int main(){
    float v1 = 17.90f;
    float v2 = 3.1415926535798932f;

    cout.setf(ios_base::showpoint);
    cout.precision(4);
    cout << "v1 = " << v1 << endl;
    cout << "v2 = " << v2 << endl;

    return 0;
}

执行结果为：

1
2
v1 = 17.90
v2 = 3.142

多数人更愿意”精度“被定义为小数点后的位数。

cout.setf(ios_base::floatfield, ios_base::fixed)将cout设置为定点小数模式，在该模式下，”精度”表示小数点后的位数，见下述程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;

int main(){
    float v1 = 17.90f;
    float v2 = 3.1415926535798932f;

    cout.precision(4);
    cout.setf(ios_base::floatfield,ios_base::fixed);
    cout << "v1 = " << v1 << endl;
    cout << "v2 = " << v2 << endl;

    return 0;
}

执行结果为：

1
2
v1 = 17.9000
v2 = 3.1416

cout.setf(ios_base::floatfield, ios_base::scientific)将cout设置为科学计数法模式，在该模式下，“精度”也表示小数点后的位数，见下述程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;

int main(){
    float v1 = 17.90f;
    float v2 = 3.1415926535798932f;

    cout.precision(4);
    cout.setf(ios_base::floatfield,ios_base::scientific);
    cout << "v1 = " << v1 << endl;
    cout << "v2 = " << v2 << endl;

    return 0;
}

执行结果为：

1
2
v1 = 1.7900e+001
v2 = 3.1416e+000

5. 应用setf( )进行格式控制

cout的setf( )成员函数有两个原型。

原型1： fmtflags setf(fmtflags)

fmtflags常量 用途
ios_base::boolalpha 将bool型输出为true或flase
ios_base::showbase 显示进制(八进制 - 0, 十六进制 - 0x)
ios_base::showpoint 总显示小数点，位数不足时补0
ios_base::uppercase 对16进制输出或者科学计数法中的E使用大写字母
ios_base::showpos 为正数输出显示+号

请结合下述代码及其执行结果来理解上述fmtflags常量的用途。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;

int main(){
    int v = 17;

    cout << "true = " << true << endl; //true被输出为"1"
    cout.setf(ios_base::boolalpha);    //按"true"/"false"输出布尔型
    cout << "false = " << false << endl; //false被输出为"false"

    cout.setf(ios_base::showpos);  //正数显示+号，但通常只在10进制时有效
    cout << "v1 = " << v << endl;

    cout << "v2 = " << hex << v << endl;
    cout.setf(ios_base::showbase); //显示0,0x等进制符号
    cout.setf(ios_base::uppercase);//相关字母大写
    cout << "v3 = " << hex << v << endl;

    return 0;
}

上述代码的执行结果为：

1
2
3
4
5
true = 1            //ios_base::boolalpha设置前，true被输出为1
false = false       //ios_base::boolalpha设置后，false被输出为false
v1 = +17            //ios_base::showpos导致十进制正数前出现+号
v2 = 11             //16进制输出
v3 = 0X11           //ios_base::showbase导致0x的添加，ios_base::uppercase使得0x变成0X

对于8进制和16进制，ios_base::showpos通常无效，因为在多数的应用场景下，人们只会使用8进制或者16进制来表达无符号的整数，而无符号整数，是没有正负概念的。

在完成某项格式设置之后，如果期望还原该项设置，可以使用unsetf( )函数。举例如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;

int main(){
    int v = 17;

    cout.setf(ios_base::showpos);
    cout << v << endl;

    cout.unsetf(ios_base::showpos);
    cout << v << endl;

    return 0;
}

上述代码的执行结果为：

1
2
+17
17

原型2： fmtflags setf(fmtflags, fmtflags)

参数1 参数2 用途
ios_base::dec ios_base::basefield 使用10进制
ios_base::oct 使用8进制
ios_base::hex 使用16进制
ios_base::fixed ios_base::floatfield 使用定点小数格式
ios_base::scientific 使用科学计数法
ios_base::left ios_base::adjustfield 左对齐
ios_base::right 右对齐
ios_base::internal 符号(+, -, 0, 0x等)左对齐，值右对齐

下述代码及其执行结果演示了通过setf( )函数的第2个原型来设置输出内容左/右对齐的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <cmath>
using namespace std;

int main(){
    cout << "12345678901234567890" << endl;
    cout << "--------------------" << endl;

    cout.width(5);
    cout.setf(ios_base::left,ios_base::adjustfield);
    cout << "N";
    cout.width(15);
    cout.setf(ios_base::right,ios_base::adjustfield);
    cout << "2**N" << endl;
    cout << "--------------------" << endl;

    cout.setf(ios_base::showpos);
    for (auto n=-2;n<=10;n++){
        cout.width(5);
        cout.setf(ios_base::left,ios_base::adjustfield);
        cout << n;
        cout.width(15);
        cout.setf(ios_base::right,ios_base::adjustfield);
        cout << pow(2,n) << endl;
    }

    return 0;
}

上述代码的执行结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
12345678901234567890
--------------------
N               2**N
--------------------
-2             +0.25
-1              +0.5
+0                +1
+1                +2
+2                +4
+3                +8
+4               +16
+5               +32
+6               +64
+7              +128
+8              +256
+9              +512
+10            +1024

从执行结果可见，上述表格的第1列为左对齐，第2列则为右对齐。

6. 通过操作算子(manipulator)简化格式设置

下述代码的第5行与第6~7行效果相同，它们都按照16进制格式输出17，结果为11。

1
2
3
4
5
6
7
8
9
#include <iostream>
using namespace std;

int main(){
    cout << hex << 17 << endl;
    cout.setf(ios_base::hex,ios_base::floatfield);
    cout << 17 << endl;
    return 0;
}

上述代码的执行结果为：

1
2
11
11

如本文的第2部分所述，hex事实上是一个被称为操作算子(manipulator)的函数，该函数事实上通过调用setf(ios_base::hex, ios_base::floatfield)发挥作用。显然，操作算子更加用户友好。

下表介绍了常用的操作算子。

操作算子 等价setf( )调用 用途
cout << boolalpha setf(ios_base::boolalpha) 用true/false表达布尔型
noboolalpha unsetf(ios_base::boolalpha) 还原前项设置
showbase setf(ios_base::showbase) 使用0/0x表达8/16进制
noshowbase unsetf(ios_base::showbase) 还原前项设置
showpoint setf(ios_base::showpoint) 总显示小数点，位数不足时补0
noshowpoint unsetf(ios_base::showpoint) 还原前项设置
showpos setf(ios_base::showpos) 在10进制正数前显示+号
noshowpos unsetf(ios_base::showpos) 还原前项设置
uppercase setf(ios_base::uppercase) 对16进制输出或者科学计数法中的E使用大写字母
nouppercase unsetf(ios_base::uppercase) 还原前项设置
internal setf(ios_base::internal,ios_base::adjustfield) 符号(+, -, 0, 0x等)左对齐，值右对齐
left setf(ios_base::left,ios_base::adjustfield) 左对齐
right setf(ios_base::right,ios_base::adjustfield) 右对齐
oct setf(ios_base::oct,ios_base::basefield) 8进制
dec setf(ios_base::dec,ios_base::basefield) 10进制
hex setf(ios_base::hex,ios_base::basefield) 16进制
fixed setf(ios_base::fixed,ios_base::floatfield) 定点小数
scientific setf(ios_base::scientific,ios_base::floatfield) 科学计数法

此外，通过头文件iomanip还可以引入另外几个重要的操作算子。iomanip是input & output manipulator的缩写。

操作算子 等效于 用途
setw(n) cout.width(n) 设置输出宽度
setprecision(n) cout.precision(n) 设置输出”精度”
setfill(x) cout.fill(x) 设置填充字符

下述代码简单演示了操作算子的使用方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

int main(){
    cout << fixed;
    cout << setw(6) << left << "N"
         << setw(12) << left << "log2N"
         << setw(12) << right << "log10N" << endl;
    cout << "-----------------------------------------" << endl;
    for (auto n = 1; n<=10; n++){
        cout << setw(6) << setfill('-') << left << n << setfill(' ');
        cout << setw(12) << setprecision(4) << left << log2(n);
        cout << setw(12) << setprecision(5) << right << log10(n) << endl;
    }

    return 0;
}

上述代码的执行结果为：

1
2
3
4
5
6
7
8
9
10
11
12
N     log2N             log10N
-----------------------------------------
1-----0.0000           0.00000
2-----1.0000           0.30103
3-----1.5850           0.47712
4-----2.0000           0.60206
5-----2.3219           0.69897
6-----2.5850           0.77815
7-----2.8074           0.84510
8-----3.0000           0.90309
9-----3.1699           0.95424
10----3.3219           1.00000

  C/C++ Qt