C++笔记-输入,输出和文件

"雪菜x和纱"
封面作者

流和缓冲区

　　C++程序把输入和输出看作字节流.输入时,程序从输入流中抽取字节;输出时,程序将字节插入到输出流中.输入流中的字节可能来自键盘/硬盘/程序. 输出流中的字节可以流向屏幕/打印机/硬盘/程序.换句话说,流充当了程序和流源(流的来源)或流目标之间的桥梁.C++程序处理输出的方式将独立于其去向,因此管理输入分:
　　○ 将流与输入去向的程序关联起来
　　○ 将流与文件链接起来.
　　换句话说,输入流需要两个链接,每端各一个.文件端链接来源,程序段链接将流的输出部分转存到程序中; 同样对输出流的管理包括将输出流连接到程序以及将输出目标与流关联起来;
　　通常使用缓冲区可以更高效地处理输入输出.缓冲区是用作中介的内存块,将信息从设备传输到程序或从程序传输给设备的临时存储工具.
　　缓冲方法从磁盘上读取大量信息,讲这些信息存在缓冲区中,然后每次从缓冲区里读取一个字节,因为从内存中读取单个字节的速度非常快.所以这种方法更快更方便.达到缓冲区尾部之后程序将从磁盘上读取另一块数据.输出时程序首先填满缓冲区.然后把成块数据传给硬盘,并清空缓冲区,已被下一批输出使用.这被称为刷新缓冲区(flushing the buffer).

流,缓冲区和iostream文件

　　○ streambuf类维缓冲区提供内存,并提供了用于填充缓冲区,访问缓冲区内容,刷新缓冲区和管理缓冲区内存的类方法.
　　○ ios_base 类表示流的一般特征,如是否可读取,是二进制流还是文本流等;
　　○ ios类基于ios_base,其中包括了一个指向streambuf对象的指针成员;
　　○ ostream类是从iios类派而来的, 提供了输出的方法;
　　○ istream 类也是从ios类派来的,提供了输入方法;
　　○ iostream类是基于istream和ostream类的 因此继承了输入输出方法;

一些ostream方法

　　除了大家喜闻乐见的方法之外,ostream类提供了put()方法和write()方法.前者用于显示字符.后者用于显示字符串.
　　最初,put()方法原型如下:
　　 ostream & put(char);
　　当前标准被模板化,以适用于wchar_t:
　　 cout.put('W');
　　还可以将数值类型参数(如int)用于put,这样:
　　 cout.put(65) // 输出A
　　 cout.put(66.3) //转为66 输出B
　　write()方法显示整个字符串,模板原型如下:
　　basic_ostream<charT,traits>&write(const char_type* s,streamsize n)
　　第一个参数提供了要显示的字符串的地址,第二个参数指出要显示多少个字符串.

下面是一个及其智障的示例:

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
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    const char * s1 = "Florida";
    const char * s2 = "Kansas";
    const char * s3 = "Euphoria";
    
    int len = strlen(s2);
       cout << "Increasing LOOP" << endl;
    
    int i;
    for(i = 1; i <= len; i++)
    {
        cout.write(s2,i);
        cout <<endl;
    }
    cout << "Decreasing LOOP:";
    for(i = len; i > 0; i--)
    cout.write(s2,i) << endl;
    cout << "Exceeding string length: " << endl;
    cout.write(s2,len+5) << endl;
    
    return 0;
}

需要注意的是,write()方法并不会在遇到空字符的时候自动停止打印.而是只打印指定数目的字符.即使超出了字符的边界.

刷新输出缓冲区

　　在屏幕输出时,程序不必等到缓冲区被填满.列如,将换行符发送到缓冲区之后.将刷新缓冲区.多数C++实现都会在输入即将发生的时候刷新缓冲区.
　　可以手动控制刷新缓冲区: 控制符flush刷新缓冲区,而控制符endl刷新缓冲区并插入一个换行符.

1
2
cout << "Kazusa" << flush;
cout << "Setsuna" << endl;

其实控制符也是函数 可以直接调用flush()来刷新缓冲区:
　　flush(cout);

用cout进行格式化

###　　1.修改显示时使用的计数系统:
　　　 ostream类是从ios类派生而来的.而后者是从ios_base派生来的.ios_base类里都是描述格式状态的信息.例如,一个类成员中某些位决定了使用的技术系统,而另一个成员决定了字段宽度.通过使用控制符(manipulator),可以控制显示整数时使用的计数系统.比如控制字段宽度,和小数尾数.
　　　 要控制整数以十进制,十六进制,八进制.可以使用dec,hex和oct控制符.
　　　 如hex(cout) 或 cout<< hex 将其技术系统格式状态设置为16进制;
　　　 下面是一个比较智障的栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    int main()
{
    cout << "Enter an integer;";
    int n;
    cin >> n;
    cout << "n    n*n" <<endl;
    cout << n << "    " << n*n << "(decimal)" << endl;
    cout << hex;
    cout << n << "    ";
    cout << n*n << " (hexadecimal)" << endl;
    cout << oct << n << "    " << n * n << "(octal)" << endl;
    dec(cout);
    cout << n << "    "<< n *n << " (decimal)" << endl;
    return 0;
}

###　　2.调整字段宽度
　　在上个代码示例中,输出各列没有对齐,可以使用width函数将长度不同的数字放到宽度相同的字段中:
　　int width();
　　int width(int i);
　　第一种格式返回字段宽度的当前设置,第二种格式将宽度设置为i个空格,并返回以前的字段宽度值,且width方法只影响将显示的下一个项目.然后字段宽度将恢复为默认,下面是个书上的例子:

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>
  int main()
  {
      using namespacestd
      int w = cout.width(30);
      cout << "default field width = " << w << endl;
      cout.with(5);
      cout << "N" << ':';
      cout.width(8);
      cout <<"N*N" << endl;
      
      for(long i=1; i <= 100; i*=10)
      {
          cout.width(5);
          cout << i << ':';
          cout.width(5);
          cout<<i*i<<endl;
      }
      return 0;
  }
  
  /*输出:
      default field width = 0
  N:     N*N
  1:       1
 10:     100
100:   10000
  */

　　上诉输出中,值在字段中右对齐,右对齐时空格被插入到值的左侧,cout通过加入空格来填满整个字段,用来填充的字符叫做填充字符(fill chararcter),并且右对齐是默认的;w的值为0是因为cout.width(30)返回的是以前的字段宽度,而不是刚设置的值.

###　　3.填充字符
　　默认使用空格填充字段中未被使用的部分,可以用fill()成员来改变填充字符,而且新的填充字段将一直有效,直到更改他为止,用星号填充:cout.fill('*')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    int main()
{
    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] << endl;
    }
    return 0;
}
/*输出
waldo Whipsnade: ****900
Wilmarie Wooper: ***1350
*/

###　　4.设置浮点数的显示精度
　　浮点数精度的函数取决于输出模式.在默认模式下,他指的是显示的总位数.在定点模式和科学模式下,精度指的是小数点后面的位数.C++默认精度为6; 将精度设置为2: cout.precision(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
#include<iostream>
using namespace std;
int main()
{
    float p1 = 20.40;
    float p2 = 1.9 + 8.0 /9.0;
    cout << "p1:" << p1 << endl;
    cout << "p2:" << p2 << endl;
    cout.precision(2);
    cout << "p1(2): " << p1 << endl;
    cout << "p2(2):" << p2 << endl;
    return 0;
    
    /*
    输出
p1:20.4
p2:2.78889
p1(2): 20
p2(2):2.8
*/

###　　5.打印末尾的0和小数点
　　下面的函数调用使cout显示末尾的小数点:cout.setf(ios_base::showpoint);showpoint是ios_base类中定义的类级静态常量;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
using namespace std;
int main()
{
    float p1 = 12.40;
    float p2 = 1.9+8.0/9.0;
    cout.setf(ios_base::showpoint);
    cout << "p1:" << p1 << endl;
    cout << "p2:" << p2 << endl;
    cout.precision(2);
    cout << "(2)p1" << p1 << endl;
    cout << "(2)p2" << p2 << endl;
    return 0;
}
/* 输出
p1:12.4000
p2:2.78889
(2)p1:12.
(2)p2:2.8
*/

###　　6.setf()
　　ios_base类有一个受保护的数据成员,其中的各位(标记) ,像开关一样分别控制着格式化的各个方面,打开开关称为设置标记,并将相应位设为1.而setf()函数提供了一种调整标记的途径:
　　setf()有俩原型.第一个:
　　fmtflags setf(fmtflags);
　　fmtflags是bitmask类的typedef,用于存储标记格式;ios_base定义了代表位值的常量:

　　○ ios_base::boolalpha: 输入和输出bool值,可以为true或false;
　　○ ios_base::showbase: 对于输出,使用C++基数前缀 0 0x
　　○ ios_base::showpoint: 显示末尾的小数点
　　○ ios_base::uppercase: 对于十六进制输出 使用大写字符E表示法
　　○ ios_base::showpos: 在整数前面加上+

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>
using namespace std;
int main()
{
    int temp = 63;
    cout.setf(ios_base::showpos);
    cout << "showpos: "<<temp << endl;
    cout << hex << "hex: " << temp << endl;
    cout.setf(ios_base::uppercase);
    cout.setf(ios_base::showbase);
    cout <<"uppercase & showbase: " << temp << endl;
    cout.setf(ios_base::boolalpha);
    cout << "boolalpha(true): " <<true << endl;
    return 0;
}
/*输出
showpos: +63
hex: 3f
uppercase & showbase: 0X3F
boolalpha(true): true
*/

　　第二个seft()原型接受两个参数,并返回以前的设置:
　　fmtflags setf(fmtflags, fmtflags);
　　函数的这种格式用于设置由多位控制的格式选项; 第一参数和以前一样,也是一个包含了所需设置的fmtlages值.第二参数指出要清除第一个参数中的哪些位;
　　setf()函数是ios_base类的一个成员函数;由于这个类是ostream的基类,因此可以使用cout来调用该函数:
　　ios_base::fmtflags old = cout.setf(ios::left, ios::adjustfield)
　　要恢复之前的可以:
　　cou.setf(old,ios::adjustfield);
　　
　　
　　书上的例子:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
    #include <iostream>
#include <cmath>
using namespace std;
int main()
{
    //使用左对齐，显示加号，显示尾随零，精度为3
    cout.setf(ios_base::left,ios_base::adjustfield);
    cout.setf(ios_base::showpos);
    cout.setf(ios_base::showpoint);
    cout.precision(3);
    //使用e表示法,保存旧的格式设置
    ios_base::fmtflags old = cout.setf(ios_base::scientific,ios_base::floatfield);
    cout << "左对齐:" << endl;
    long n;
    for(n = 1; n < 41; n+= 10)
    {
        cout.width(4);
        cout << n << "|";
        cout.width(12);
        cout << sqrt(double(n)) << "|" << endl;
    }
    //改为内对齐
    cout.setf(ios_base::internal,ios_base::adjustfield);
    //恢复默认浮点显示样式
    cout.setf(old,ios_base::floatfield);
    cout << "内对齐:" << endl;
    for(n = 1; n < 41; n+= 10)
    {
        cout.width(4);
        cout << n << "|";
        cout.width(12);
        cout << sqrt(double(n)) << "|" << endl;
    }
    //右对齐,使用定点计数法
    cout.setf(ios_base::right,ios_base::adjustfield);
    cout.setf(ios_base::fixed,ios_base::floatfield);
    cout << "右对齐:" << endl;
    for(n = 1; n < 41; n+= 10)
    {
        cout.width(4);
        cout << n << "|";
        cout.width(12);
        cout << sqrt(double(n)) << "|" << endl;
    }
    return 0;
}
/* 输出:
左对齐
+1  |+1.000e+000 |
+11 |+3.317e+000 |
+21 |+4.583e+000 |
+31 |+5.568e+000 |
内对齐
+  1|+       1.00|
+ 11|+       3.32|
+ 21|+       4.58|
+ 31|+       5.57|
右对齐
  +1|      +1.000|
 +11|      +3.317|
 +21|      +4.583|
 +31|      +5.568|
 */

##　　6.iomanip
　　如果嫌前面那些麻烦的话,头文件iomanip中提供了一些其他控制符,他们能提供前面的部分服务.setprecision(),setfill() 和 setw(); setprecision()控制符接受一个指定精度的整数参数; setfill()控制符接受一个指定填充字符的char参数;setw()控制符接受一个指定字段宽度的整数参数;并且他们都能通过cout链接起来;
　　书上的例子:

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
29
30
31
32
33
34
35
36
37
38
#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" << endl;
    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;
}
/* 输出
     N   square root    fourth root
....10       3.162        1.7783
....20       4.472        2.1147
....30       5.477        2.3403
....40       6.325        2.5149
....50       7.071        2.6591
....60       7.746        2.7832
....70       8.367        2.8925
....80       8.944        2.9907
....90       9.487        3.0801
...100      10.000        3.1623
*/

　　

　　

赏

到目前为止,您不必打赏什么

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    2、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: true
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

  • {{ item.title }}

    {{ item.date|dateformat }}

    #{{ tag.name }}

高中弱鸡学渣,低级码畜,Qt & C++养成中.想要学画画 技能树多线程划水中,脑回路清奇,反射弧可绕太阳系一圈. 懒癌晚期,绝赞抗癌中