C++_IO与文件2-用cout进行输出

C++将输出流看作是字节流，在程序中，很多数据被组织成比字节更大的单位。

例如int类型由16位或者32位的二进制值表示；double值由64位的二进制数据表示；

但是在将字节流发送给屏幕时，希望每个字节表示一个字符。

举个例子：要在屏幕上显示数字-2.34时，需要5个字符（- 2 . 3 4）。

而不是这个值得内部浮点表示发送到屏幕上。

ostream类最重要的任务就是将数值类型转换为以文本形式表示的字符流。

ostream类将数据的内部表示（二进制位模式）转换为由字符字节组成的输出流。

//输出流是字节流，所以要显示的东西必须进行转换，转换成字符编码的字节流；

=====================================================

一、重载的<<运算符

ostream类重新定义了<<运算符，方法是将其重载为输出。该重载运算符能够识别C++中所有的基本类型；

<<运算符的默认含义是按位左移运算符。

例如：cout<<88对应于下面的方法原型：

ostream & operator<<(int);

operator<<(int)函数接受一个int参数，返回一个指向ostream对象的引用，这使得可以将输出连接起来，如下所示：

cout<<"I'm feeling sedimental over "<<boundary<<" ";

1、输出和指针

ostream类为下面的指针类型提供了插入运算符函数：

const signed char *

const unsigned char *

const char *

void *

C++用指向字符串存储位置的指针来表示字符串。指针的形式可以是char数组名、显式的char指针或用引号括起的字符串。

方法使用字符串中的终止空字符来确定何时停止显示字符。

void * 指的是其他类型的指针，会打印地址的数值表示；如果要获得字符串的地址，则必须将其强制转换为其他类型：

char * amount = "dozen";

cout<<amount;              //print the string "dozen"

cout<<(void *)amount;   //prints the address of the "dozen" string

 

2、拼接输出

插入运算符的所有返回为ostream &，也就是说，原型的格式如下：

ostream & operator<<(type);

type是要显示的数据类型，ostream &意味着将返回一个指向ostream对象的引用。

指向哪个对象呢？函数定义指出，引用将指向用于调用该运算符的对象。

换句话说，运算符函数的返回值为调用运算符的对象。

例如：cout<<"potluck"返回的是cout对象。这种特性使得能够通过插入运算符来连接输出。 

=====================================================

二、其他ostream方法

ostream类还提供了put()方法和write()方法；前者显示字符、后者用于显示字符串；

可以用类方法表示法来调用put：

cout.put('W');   //display the W character

cout是调用对象的方法、put是类成员函数。该函数也返回一个指向调用对象的引用，因此可以用它拼接输出；

write()方法显示整个字符串，其模板原型如下：

basic_ostream<char T, traits> & write(const char_type* s, streamsize n);

接下来看一个例子：

//write.cpp  -- using cout.write()
#include <iostream>
#include <cstring>

int main()
{
    using std::cout;
    using std::endl;
    const char * state1 = "Florida";
    const char * state2 = "Kansas";
    const char * state3 = "Euphoria";

    int len = std:strlen(state2);
    cout<<"Increasing loop index:
";
    int i;
    for (i = 1; i<=len; i++)
    {
        cout.write(state2, i);
        cout<<endl;
    }

//concatenate output
    cout<<"Decreasing loop index:
";
    for(i = len; i>0; i--)
        cout.write(state2, i) <<endl;

//exceed string length
    cout<<"Exceeding string length:
";
    cout.write(state2, len+5)<<endl;

    return 0;
}

程序输出结果：

Increasing loop index:

K

Ka

Kan

Kans

Kansa

Kansas

Decreasing loop index:

Kansas

Kansa

Kans

Kan

Ka

K

另外，write()方法也可以用于数值数据，可以将数字的地址强制转换为char *，然后传递给它：

long val = 560031841;

cout.write((char *) & val, sizeof(long)); 

这不会将数字转换为相应的字符，而是传输内存中存储的位表示。

例如，4字节的long值（560031841）将作为4个独立的字节被传输。输出设备将把每个字节作为ASCII码进行解释。

因此在屏幕上，560031841将被显示为4个字符的组合，这很可能是乱码。

write()确实为将数值数据存储在文件中提供了一种简洁、准确的方式。

=====================================================

三、刷新输出缓冲区

缓冲区一般为512个字节或者其整数倍。

输出不会立即发送到目标地址，而是被存储在缓冲区中，直到缓冲区填满。

然后程序将刷新（flush）缓冲区，把内容发送出去，并清空缓冲区，以填充新的数据。

但是对于屏幕输出而言，填充缓冲区的重要性低很多。

所幸，在屏幕输出时，程序不必等到缓冲区被填满后才刷新缓冲区；

当换行符发送到缓冲区后，将刷新缓冲区。

cout<<"Hello, good-looking! "<<flush;

cout<<"Wait just a moment, please"<<endl;

控制符flush刷新缓冲区，而控制符endl也刷新缓冲区；

cout<<"Enter a number:";

float num;

cin>>num;

上面这段代码，没有刷新缓冲区，从而显示Enter a number: 字符，那样的话用户也就无法从屏幕感知到这个提示语来进行输入；

=====================================================

四、用cout进行格式化

1、修改显示时使用的计数系统

可以使用：hex(cout) 表示下面的函数调用将cout对象的计数系统格式状态设置为十六进制。 

但通常的使用方法为：cout<<hex;

//manip.cpp  --  using format manipulators
#include <iostream>

int main()
{
    using namespace std;
    cout<<"Enter an integer: ";
    int n;
    cin>> n;

    cout<<"n      n*n
";

//set to hex mode
    cout<<hex;
    cout<<n << "   ";
    cout<<n*n<<" (hexdecimal)
";

//set to octal mode
    cout<<oct<<n<<"   "<<n*n<<" (octal)
";

//alternative way to call a manipulator
    dec(cout);
    cout<<n<<"     "<<n*n<<" (decimal)
";

    return 0; 
}

运行结果为：

Enter an integer:13

n       n*n

13     169(decimal)

d        a9 (hexadecimal)

15     251(octal)

13     169(decimal)

2、调整字段宽度

　　先看一个例子：

　　　　cout<<'#';

　　　　cout.width(12);

　　　　cout<<12<<"#"<<  24<<"# ";

　　显示结果：

　　　　#          12#24#

我们可以发现第一个12被设置为宽度12的字段，12这个字符被放到最右边，这被称为右对齐。

然后字段宽度恢复为默认值。

所以可知width()方法只影响接下来显示的一个项目，然后字段宽度将恢复为默认值。

另外注意一点，C++永远不会截短数据，因此如果试图在宽度为2的字段中打印一个7位值，C++将增宽字段，以容纳该数据。

C/C++的原则是显示所有数据比保持列的整洁更重要。

//width.cpp   -- using the width method 
#include <iostream>

int main()
{
    using std :: cout;
    int w = cout.width(30);
    cout<<"default field width =" << w <<" : 
";
    cout.width(5);
    cout<<"N"<<' : ';
    cout.width(8);
    cout<<"N*N"<<":
";
 
    for (long i = 1; i<=100; i*=10)
    {
        cout.width(5);
        cout<<i<<' : ';
        cout.width(8);
        cout<<i * i<<":
";
    } 

    return 0;
}

运行结果：

           default field width = 0;

    N:     N * N:

    1:           1:

  10:       100:

100:   10000:

空格被插入到值的左侧，用来填充的字符叫做填充字符。右对齐是默认的。

默认字段宽度是0，因为C++总会增长字段，以容纳数据，因此这种值适用于所有数据。

3、填充字符

在默认情况下，cout用空格填充字段中未被使用的部分，可以用fill()成员函数来改变填充字符。

下面的函数调用将填充字符改为星号：

cout.fill(' * '); 

注意，与字段宽度不同的是，新的填充字符将一直有效，直到更改它为止；

//fill.cpp  -- changing fill character for fields
#include<iostream>  

int main()
{
    using std::cout;
    cout.fill('*');
    const char * staff[2] = {"Waldo Whipsnade", "Wilmarie Wooper"};
    long bonus[2] = {900, 1350};
    
    for (int i = 0; i < 2; i++)
    {
        cout<<staff[i]<<" : $";
        cout.width(7);
        cout<<bonus[i]<<"
";
    }
    return 0;
}

运行结果：

Waldo Whipsnade: $****900
Wilmarie Wooper: $***1350

4、设置浮点数的显示精度

浮点数精度的含义取决于输出模式；

在默认模式下，它指的是显示的总位数；

在定点模式和科学模式下，精度指的是小数点后面的位数。

C++的默认精度为6位（但末尾的0将不显示）。 

precision()成员函数使得能够选择其他值。

下面的语句将cout的精度设置为2：cout.precision(2)

与fill()类似，新的精度设置将一直有效，直到被重新设置。

//precise.cpp  -- setting the precision
#include<iostream>  

int main()
{
    using std::cout;
    float price1 = 20.40;
    float price2 = 1.9 + 8.0/9.0;
    
    cout<<""Fiery Friends" is $"<<price1<<"!
";
    cout<<""Fiery Friends" is $"<<price2<<"!
";
    
    cout.precision(2)
    cout<<""Fiery Friends" is $"<<price1<<"!
";
    cout<<""Fiery Friends" is $"<<price2<<"!
";
    
    return 0;
}

运行结果：

"Furry Friends" is 20.4!
"Furry Friends" is 2.78889!
"Furry Friends" is 20!
"Furry Friends" is 2.8!

5、打印末尾的0和小数点

对于有些输出，保留末尾的0将更为美观。

但ios_base类提供了一个setf()函数（用于set标记），能够控制多种格式化特性。

这个类还定义了很多常量，可用作该函数的参数；

例如，下面的函数调用使cout显示末尾小数点：

cout.setf(ios_base :: showpoint);

使用默认的浮点格式时，上述语句还将导致末尾的0倍显示出来。

如果使用默认精度（6位）时，cout不会将2.00显示为2，而是将它显示为2.000000。

//precise.cpp  -- setting the precision
#include<iostream>  

int main()
{
    using std::cout;
    using std::ios_base;
    
    float price1 = 20.40;
    float price2 = 1.9 + 8.0/9.0;
    
    cout.setf(ios_base::showpoints);
    cout<<""Fiery Friends" is $"<<price1<<"!
";
    cout<<""Fiery Friends" is $"<<price2<<"!
";
    
    cout.precision(2)
    cout<<""Fiery Friends" is $"<<price1<<"!
";
    cout<<""Fiery Friends" is $"<<price2<<"!
";
    
    return 0;
}

运行结果：

"Fiery Friends" is $20.4000!
"Fiery Friends" is $2.78889!
"Fiery Friends" is $20.!
"Fiery Friends" is $2.8!

6、再谈setf()

ios_base类定义了代表位值的常量；//由于这些格式常量都在ios_base类中定义。因此使用它们时，必须加上作用域解析运算符；

ios_base : : boolalpha   输入和输出bool值，可以为true或false

ios_base : : showbase  对于输出，使用C++基数前缀（0， 0x）

ios_base : : showpoint  显示末尾的小数点

ios_base : : uppercase  对于16进制输出，使用大写字母，E表示法

ios_base : : showpos   在整数前面加上+

setf()函数由两个原型。第一个为：

fmtflags setf(fmtflags);

fmtflags 是bitmask类型的typedef名，用于存储格式标记。

bitmask类型是用来存储各个位值的类型。

//setf.cpp  -- using setf() to control formatting
#include<iostream>  

int main()
{
    using std::cout;
    using std::endl;
    using std::ios_base;
    
    int temperature = 63;
    cout<<"Today's water temperature: ";
    cout.setf(ios_base :: showpos);  //show plus signal
    cout<< temperature << endl;

    cout<<"For our programming friends, that's
";
    cout<< std::hex << temperature << endl;  //use hex
    cout.setf(ios_base::uppercase);  //use uppercase in hex
    cout.setf(ios_base::showbase);  //use 0X prefix for hex
    cout<<"or
";
    cout<<temperature<<endl;
    cout<<"How "<<true<<"!   oops  -- How ";
    cout.setf(ios_base::boolappha);
    cout<<true<<<<"!
";
    
    return 0;
}

第二个setf()原型接受两个参数，并返回以前的设置：

fmtflags setf(fmtflags, fmtflags);

函数的这种重载格式用于设置由多位控制的格式选项。

第一个参数和以前一样，也是一个包含了所需设置的fmtflags值。

第二个参数指出要清除第一个参数中的哪些位。

　　　　　　setf(long, long)的参数

  第二个参数                 第一个参数           含义

ios_base::basefield     ios_base::dec      使用基数10

                                   ios_base::oct       使用基数8

                                   ios_base::hex      使用基数16

ios_base::floatfield     ios_base::fixed     使用定点计数法

                                  ios_base::scientific 使用科学计数法

ios_base::adjustfield  ios_base::left        使用左对齐

                                  ios_base::right      使用右对齐

                                  ios_base::internal   符号或基数前缀

7、标准控制符

使用setf()不是进行格式化的，对用户最友好的方法；

C++提供了多个控制符，能够调用setf()，并自动提供正确的参数；

　　　　　　一些标准控制符

 　　控制符　　　　　　　　调用

     boolalpha                    setf(ios_base::boolalpha)

　 noboolalpha               unsetf(ios_base::noboolalpha)

    showbase                   setf(ios_base::showbase)

   noshowbase               unsetf(ios_base::showbase)

     等等。。。

 

8、头文件iomanip

使用iomanip工具来设置一些格式值不太方便。

为了简化工作，C++在头文件iomanip中提供了其他一些控制符，它们能够提供前面讨论过的服务，但表示起来更方便。

3个最常用的控制符分别是：setprecision()、setfill()、setw()；

它们分别用来设置精度、填充字符、字段宽度；

//iomanio.cpp  -- using manipulators from iomanip
#include<iostream>  
#include<iomanip>
#include<cmath>

int main()
{
    using namespace std;
    cout<<fixed<<right;
    
    cout<<setw(6)<<"N"<<setw(14)<<"square root"<<setw(15)<<"fourth root
";
    
    double root;
    for(int n =10; n<=100; n+=10)
    {
        root = sqrt(double(n));
        cout<<setw(6)<<setfill('.')<<n<<setfill(' ')
            <<setw(12)<<setprecision(3)<<root
            <<setw(14)<<setprecision(4)<<sqrt(root)
            <<endl;
    }
    
    return 0;
}