C++ IO流

IO流

1.流类库结构

程序的输入指的是从输入文件将数据传送给程序,程序的输出指的是从程序将数据传送给输出文件。


C++输入输出包含以下三个方面的内容:

  • 对系统指定的标准设备的输入和输出。即从键盘输入数据,输出到显示器屏幕。这种输入输出称为标准的输入输出,简称标准I/O。
  • 以外存磁盘文件为对象进行输入和输出,即从磁盘文件输入数据,数据输出到磁盘文件。以外存文件为对象的输入输出称为文件的输入输出,简称文件I/O。
  • 对内存中指定的空间进行输入和输出。通常指定一个字符数组作为存储空间(实际上可以利用该空间存储任何信息)。这种输入和输出称为字符串输入输出,简称串I/O。

C++的输入输出对C语言的扩展和加强

在C++的输入输出中,编译系统对数据类型进行严格的检查,凡是类型不正确的数据都不可能通过编译。因此C++的I/O操作是类型安全(type safe)的。C++的I/O操作是可扩展的,不仅可以用来输入输出标准类型的数据,也可以用于用户自定义类型的数据。

C++通过I/O类库来实现丰富的I/O功能。这样使C++的输人输出明显地优于C 语言中的printf和scanf,但是也为之付出了代价,C++的I/O系统变得比较复杂,要掌握许多细节。

流类库结构

ios是抽象基类,由它派生出istream类和ostream类,两个类名中第1个字母i和o分别代表输入(input)和输出(output)。 istream类支持输入操作,ostream类支持输出操作, iostream类支持输入输出操作。iostream类是从istream类和ostream类通过多继承而派生的类。其继承层次见上图表示。 
C++对文件的输入输出需要用ifstreamofstream类,两个类名中第1个字母i和o分别代表输入和输出,第2个字母f代表文件 (file)。ifstream支持对文件的输入操作, ofstream支持对文件的输出操作。类ifstream继承了类istream,类ofstream继承了类ostream,类fstream继承了 类iostream。

有关头文件

iostream类库中不同的类的声明被放在不同的头文件中,用户在自己的程序中用#include命令包含了有关的头文件就相当于在本程序中声明了所需 要用到的类。可以换 —种说法:头文件是程序与类库的接口,iostream类库的接口分别由不同的头文件来实现。常用的有

头文件 含义
iostream 包含了对输入输出流进行操作所需的基本信息。
fstream 用于用户管理的文件的I/O操作。
strstream 用于字符串流I/O。
stdiostream 用于混合使用C和C ++的I/O机制时,例如想将C程序转变为C++程序。
iomanip 在使用格式化I/O时应包含此头文件。

常见流对象

对象 含义 对应设备 对应的类 c语言中相应的标准文件
cin 标准输入流 键盘 istream_withassign stdin
cout 标准输出流 屏幕 ostream_withassign stdout
cerr 标准错误流 屏幕 ostream_withassign stderr
clog 标准错误流 屏幕 ostream_withassign stderr

在iostream头文件中定义以上4个流对象用以下的形式(以cout为例): 
ostream cout ( stdout);在定义coutostream流类对象时,把标准输出设备stdout作为参数,这样它就与标准输出设备(显示器)联系起来,如果有cout <<3;就会在显示器的屏幕上输出3。

运算符重载

“<<”和“>>”本来在C++中是被定义为左位移运算符和右位移运算符的,由于在iostream头文件中对它们进行了重载, 使它们能用作标准类型数据的输入和输出运算符。所以,在用它们的程序中必须用#include命令把iostream包含到程序中。 
1)>>a表示将数据放入a对象中。 
2)<表示将a对象中存储的数据拿出。

2.标准IO

cout流对象 
cout是console output的缩写,意为在控制台(终端显示器)的输出。强调几点。 
1) cout不是C++预定义的关键字,它是ostream流类的对象,在iostream中定义。 顾名思义,流是流动的数据,cout流是流向显示器的数据。cout流中的数据是用流插入运算符“<<”顺序加入的。cout流是容纳数据的载体,它并不是一个运算符。人们关心的是cout流中的内容,也就是向显示器输出什么。 
2)用“cout<<”输出基本类型的数据时,可以不必考虑数据是什么类型,系统会判断数据的类型,并根据其类型选择调用与之匹配的运算符重 载函数。这个过程都是自动的,用户不必干预。如果在C语言中用prinf函数输出不同类型的数据,必须分别指定相应的输出格式符,十分麻烦,而且容易出错。C++的I/O机制对用户来说,显然是方便而安全的。 
3) cout流在内存中对应开辟了一个缓冲区,用来存放流中的数据,当向cout流插人一个endl时,不论缓冲区是否已满,都立即输出流中所有数据,然后插入一个换行符并刷新流(清空缓冲区)。注意如果插人一个换行符”\n“(如cout<),则只输出和换行,而不刷新cout流(但并不是所有编译系统都体现出这一区别)。 
4) 在iostream中只对”<<”和”>>”运算符用于标准类型数据的输入输出进行了重载,但未对用户声明的类型数据的输入输出 进行重载。如果用户声明了新的类型,并希望用”<<”和”>>”运算符对其进行输入输出,按照重运算符重载来做。

cerr流对象 
cerr流对象是标准错误流,cerr流已被指定为与显示器关联。cerr的 作用是向标准错误设备(standard error device)输出有关出错信息。cerr与标准输出流cout的作用和用法差不多。但有一点不同:cout流通常是传送到显示器输出,但也可以被重定向 输出到磁盘文件,而cerr流中的信息只能在显示器输出。当调试程序时,往往不希望程序运行时的出错信息被送到其他文件,而要求在显示器上及时输出,这时 应该用cerr。cerr流中的信息是用户根据需要指定的。

注意:cerr不经过缓冲区

clog流对象

clog流对象也是标准错误流,它是console log的缩写。它的作用和cerr相同,都是在终端显示器上显示出错信息。区别:cerr是不经过缓冲区,直接向显示器上输出有关信息,而clog中的信息存放在缓冲区中,缓冲区满后或遇endl时向显示器输出。

2.1标准输入

标准输入流对象cin,重点掌握的函数

cin.get() //一次只能读取一个字符
cin.get(一个参数) //读一个字符
cin.get(三个参数) //可以读字符串
cin.getline()
cin.ignore()
cin.peek()
cin.putback()

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

输入基本类型

#include 
using namespace std;

void main()
{
    char YourName[50];
    int myInt;
    long myLong;
    double myDouble;
    float myFloat;

    cout << "请输入一个Int: ";
    cin >> myInt;
    cout << "请输入一个Long: ";
    cin >> myLong;
    cout << "请输入一个Float: ";
    cin >> myFloat;
    cout << "请输入一个Double: ";
    cin >> myDouble;

    cout << "请输入你的姓名: ";
    cin >> YourName;

    cout << "\n\n你输入的数是:" << endl;
    cout << "Int: \t" << myInt << endl;
    cout << "Long: \t" << myLong << endl;
    cout << "Float: \t" << myFloat << endl;
    cout << "Double: \t" << myDouble << endl;
    cout << "姓名: \t" << YourName << endl;
    cout << endl << endl;
    system("pause");
    return;
}

   
   
   
   
  • 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

ctr+z 会产生一个 EOF(-1)

#include 
using namespace std;

void main()
{
    char ch;
    while ((ch = cin.get()) != EOF)
    {
        std::cout << "字符: " << ch << std::endl;
    }
    std::cout << "\n结束.\n";

    return;
}

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15


读一个字符 链式编程

#include 
using namespace std;

void main()
{
    char a, b, c;
    cin.get(a);
    cin.get(b);
    cin.get(c);
    cout << a << b << c << endl;

    cout << "开始链式编程" << endl;
    cout.flush();

    cin.get(a).get(b).get(c);
    cout << a << b << c << endl;

    return;
}

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20


cin.getline() 可以接受空格

#include 
using namespace std;

void main()
{
    char buf1[256];
    char buf2[256];
    cout << "\n请输入你的字符串 不超过256";
    cin.getline(buf1, 256, '\n');
    cout << buf1 << endl;

    // 
    cout << "注意: cin.getline() 和 cin >> buf2 的区别, 能不能带空格 " << endl;
    cin >> buf2; //流提取操作符 遇见空格 停止提取输入流
    cout << buf2 << endl;

    system("pause");
    return;
}

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

缓冲区实验

1 输入 “aa bb cc dd” 字符串入缓冲区 
2 通过 cin >> buf1; 提走了 aa 
3 不需要输入 可以再通过cin.getline() 把剩余的缓冲区数据提走

#include 
using namespace std;

void main()
{
    char buf1[256];
    char buf2[256];

    cout << "请输入带有空格的字符串,测试缓冲区" << endl;
    cin >> buf1;
    cout << "buf1:" << buf1 << endl;

    cout << "请输入数据..." << endl;

    //缓冲区没有数据,就等待; 缓冲区如果有数据直接从缓冲区中拿走数据
    cin.getline(buf2, 256);
    cout << "buf2:" << buf2 << endl;

    system("pause");
    return;
}

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

ignore 和 peek

#include 
using namespace std;

void main()
{
    int  intchar;
    char buf1[256];
    char buf2[256];

    cout << "请输入带有空格的字符串,测试缓冲区 aa bb cc dd ee " << endl;
    cin >> buf1;
    cout << "buf1:" << buf1 << endl;

    cout << "请输入数据..." << endl;
    cin.ignore(2);
    intchar = cin.peek();
    cout << "缓冲区若有数据,返回第一个数据的asc码:" << intchar << endl;

    //缓冲区没有数据,就等待; 缓冲区如果有数据直接从缓冲区中拿走数据
    cin.getline(buf2, 256);
    cout << "buf2:" << buf2 << endl;

    intchar = cin.peek(); //没有缓冲区 默认是阻塞模式 
    cout << "缓冲区若有数据,返回第一个数据的asc码:" << intchar << endl;

    return;
}

   
   
   
   
  • 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 
#include 
using namespace std;

void main()
{
    cout << "Please, enter a number or a word: ";
    char c = cin.get();

    if ((c >= '0') && (c <= '9')) //输入的整数和字符串 分开处理
    {
        int n; //整数不可能 中间有空格 使用cin >>n
        cin.putback(c);
        cin >> n;
        cout << "You entered a number: " << n << '\n';
    }
    else
    {
        string str;
        cin.putback(c);
        getline(cin, str); // //字符串 中间可能有空格 使用 cin.getline();
        cout << "You entered a word: " << str << '\n';
    }   
    system("pause");


    return;
}

   
   
   
   
  • 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

2.2标准输出

标准输出流对象cout

cout.flush()
cout.put()
cout.write()
cout.width()
cout.fill()
cout.setf(标记)

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

常见案例

#include 
#include 
using namespace std;

void main()
{
    cout << "hello world" << endl;
    cout.put('h').put('e').put('l').put('\n');
    cout.write("hello world", 4); //输出的长度

    char buf[] = "hello world";
    printf("\n");
    cout.write(buf, strlen(buf));

    printf("\n");
    cout.write(buf, strlen(buf) - 6);

    printf("\n");
    cout.write(buf, strlen(buf) + 6); //给的大于buf长度 不会帮我们检查 提高速度

    printf("\n");
    system("pause");

    return;
}

   
   
   
   
  • 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


使用cout.setf()控制符

#include 
#include 
#include 
using namespace std;

void main()
{
    //使用类成员函数
    cout << "";
    cout.width(30);
    cout.fill('*');
    cout.setf(ios::showbase); //#include 
    cout.setf(ios::internal); //设置
    cout << hex << 123 << "\n";

    cout << endl;
    cout << endl;
    //manipulator(操作符、控制符)

    //使用控制阀
    cout << ""
        << setw(30)
        << setfill('*')
        << setiosflags(ios::showbase) //基数
        << setiosflags(ios::internal)
        << hex
        << 123
        << "\n"
        << endl;

    system("pause");

    return;
}

   
   
   
   
  • 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
<start>0x**************************7b<End>


<Start>0x**************************7b<End>
   
   
   
   
  • 1
  • 2
  • 3
  • 4

在输出数据时,为简便起见,往往不指定输出的格式,由系统根据数据的类型采取默认的格式,但有时希望数据按指定的格式输出,如要求以十六进制或八进制形式 输出一个 整数,对输出的小数只保留两位小数等。有两种方法可以达到此目的。 
1)使用控制符的方法; 
2)使用流对象的有关成员函数。分别叙述如下。

使用格式控制符

#include 
#include 
#include 
using namespace std;

void main()
{
    int a;
    cout << "input a:";
    cin >> a;
    cout << "dec:" << dec << a << endl; //以十进制形式输出整数
    cout << "hex:" << hex << a << endl; //以十六进制形式输出整数a
    cout << "oct:" << setbase(8) << a << endl; //以八进制形式输出整数a
    char *pt = "China"; //pt指向字符串"China"
    cout << setw(10) << pt << endl; //指定域宽为,输出字符串
    cout << setfill('*') << setw(10) << pt << endl; //指定域宽,输出字符串,空白处以'*'填充
    double pi = 22.0 / 7.0; //计算pi值
    //按指数形式输出,8位小数
    cout << setiosflags(ios::scientific) << setprecision(8);
    cout << "pi=" << pi << endl; //输出pi值
    cout << "pi=" << setprecision(4) << pi << endl; //改为位小数
    cout.unsetf(ios::scientific); //终止科学记数法状态
    cout << "pi=" << setiosflags(ios::fixed)  << pi << endl; //改为小数形式输出


    system("pause");

    return;
}

   
   
   
   
  • 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


人们在输入输出时有一些特殊的要求,如在输出实数时规定字段宽度,只保留两位小数,数据向左或向右对齐等。C++提供了在输入输出流中使用的控制符(有的书中称为操纵符)


输出双精度数

double a=123.456789012345;  // 对a赋初值

1) cout<123.456
2) cout<9)<123.456789
3) cout<6);  恢复默认格式(精度为6)
4) cout<< setiosflags(ios∷fixed);  输出: 123.456789
5) cout<8)<123.45678901
6) cout<1.234568e+02
7) cout<4)<1.2346e02

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

整数输出的例子

int b=123456;  // 对b赋初值
1) cout<123456
2) cout<1e240
3) cout<1E240
4) cout<10)<','<123456,123456
5) cout<'*')<10)<123456
6) cout<123456

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

如果在多个cout语句中使用相同的setw(n),并使用setiosflags(ios::right),可以实现各行数据右对齐,如果指定相同的精度,可以实现上下小数点对齐。

各行小数点对齐

int main( )
{
    double a=123.456,b=3.14159,c=-3214.67;
    cout<2);
    cout<10)<cout<10)<cout<10)<"pause");
    return 0;
}

   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

输出如下:

123.46 (字段宽度为10,右对齐,取两位小数)
3.14
-3214.67

   
   
   
   
  • 1
  • 2
  • 3
  • 4

先统一设置定点形式输出、取两位小数、右对齐。这些设置对其后的输出均有效(除非重新设置),而setw只对其后一个输出项有效,因此必须在输出a,b,c之前都要写setw(10)。

用流对象的成员函数控制输出格式 
除了可以用控制符来控制输出格式外,还可以通过调用流对象cout中用于控制输出格式的成员函数来控制输出格式。用于控制输出格式的常用的成员函数如下: 

流成员函数setf和控制符setiosflags括号中的参数表示格式状态,它是通过格式标志来指定的。格式标志在类ios中被定义为枚举值。因此在引用这些格式标志时要在前面加上类名ios和域运算符“::”。格式标志见表13.5。


简单示例:

#include 
#include 
#include 
using namespace std;

void main()
{ 
    int a = 21;
    cout.setf(ios::showbase);//显示基数符号(0x或)
    cout << "dec:" << a << endl; //默认以十进制形式输出a
    cout.unsetf(ios::dec); //终止十进制的格式设置
    cout.setf(ios::hex); //设置以十六进制输出的状态
    cout << "hex:" << a << endl; //以十六进制形式输出a
    cout.unsetf(ios::hex); //终止十六进制的格式设置
    cout.setf(ios::oct); //设置以八进制输出的状态
    cout << "oct:" << a << endl; //以八进制形式输出a
    cout.unsetf(ios::oct);
    char *pt = "China"; //pt指向字符串"China"
    cout.width(10); //指定域宽为
    cout << pt << endl; //输出字符串
    cout.width(10); //指定域宽为
    cout.fill('*'); //指定空白处以'*'填充
    cout << pt << endl; //输出字符串
    double pi = 22.0 / 7.0; //输出pi值
    cout.setf(ios::scientific); //指定用科学记数法输出
    cout << "pi="; //输出"pi="
    cout.width(14); //指定域宽为
    cout << pi << endl; //输出pi值
    cout.unsetf(ios::scientific); //终止科学记数法状态
    cout.setf(ios::fixed); //指定用定点形式输出
    cout.width(12); //指定域宽为
    cout.setf(ios::showpos); //正数输出“+”号
    cout.setf(ios::internal); //数符出现在左侧
    cout.precision(6); //保留位小数
    cout << pi << endl; //输出pi,注意数符“+”的位置
    system("pause");
    return ;
}

   
   
   
   
  • 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

1) 成员函数width(n)和控制符setw(n)只对其后的第一个输出项有效。如:

cout. width(6);
cout <<20 <<3.14<
   
   
   
   
  • 1
  • 2
  • 3

输出结果为 203.14. 
在输出第一个输出项20时,域宽为6,因此在20前面有4个空格,在输出3.14时,width (6)已不起作用,此时按系统默认的域宽输出(按数据实际长度输出)。如果要求在输出数据时都按指定的同一域宽n输出,不能只调用一次width(n), 而必须在输出每一项前都调用一次width(n>,上面的程序中就是这样做的。


2) 在表13.5中的输出格式状态分为5组,每一组中同时只能选用一种(例如dec、hex和oct中只能选一,它们是互相排斥的)。在用成员函数setf和 控制符setiosflags设置输出格式状态后,如果想改设置为同组的另一状态,应当调用成员函数unsetf(对应于成员函数setf)或 resetiosflags(对应于控制符setiosflags),先终止原来设置的状态。然后再设置其他状态,大家可以从本程序中看到这点。程序在开始虽然没有用成员函数setf和控制符setiosflags设置用dec输出格式状态,但系统默认指定为dec,因此要改变为hex或oct,也应当先 用unsetf 函数终止原来设置。如果删去程序中的第7行和第10行,虽然在第8行和第11行中用成员函数setf设置了hex和oct格式,由于未终止dec格式,因 此hex和oct的设置均不起作用,系统依然以十进制形式输出。 
同理,程序倒数第8行的unsetf 函数的调用也是不可缺少的。


3) 用setf 函数设置格式状态时,可以包含两个或多个格式标志,由于这些格式标志在ios类中被定义为枚举值,每一个格式标志以一个二进位代表,因此可以用位或运算符“|”组合多个格式标志。如倒数第5、第6行可以用下面一行代替: 
cout.setf(ios::internal | ios::showpos); //包含两个状态标志,用"|"组合

4) 可以看到:对输出格式的控制,既可以用控制符(如例13.2),也可以用cout流的有关成员函数(如例13.3),二者的作用是相同的。控制符是在头文件iomanip中定义的,因此用控制符时,必须包含iomanip头文件。cout流的成员函数是在头文件iostream 中定义的,因此只需包含头文件iostream,不必包含iomanip。许多程序人员感到使用控制符方便简单,可以在一个cout输出语句中连续使用多种控制符。

3.文件IO

3.1文件流及其对象

输入输出是以系统指定的标准设备(输入设备为键盘,输出设备为显示器)为对象的。在实际应用中,常以磁盘文件作为对象。即从磁盘文件读取数据,将数据输出到磁盘文件。 
和文件有关系的输入输出类主要在fstream.h这个头文件中被定义,在这个头文件中主要被定义了三个类,由这三个类控制对文件的各种输入输出操 作,他们分别是ifstream、ofstream、fstream,其中fstream类是由iostream类派生而来,他们之间的继承关系见下图所 示。


由于文件设备并不像显示器屏幕与键盘那样是标准默认设备,所以它在fstream.h头文件中是没有像cout那样预先定义的全局对象,所以我们必须自己定义一个该类的对象。 
ifstream类,它是从istream类派生的,用来支持从磁盘文件的输入。 
ofstream类,它是从ostream类派生的,用来支持向磁盘文件的输出。 
fstream类,它是从iostream类派生的,用来支持对磁盘文件的输入输出。

3.2文件的基本操作

打开文件

所谓打开(open)文件是一种形象的说法,如同打开房门就可以进入房间活动一样。 打开文件是指在文件读写之前做必要的准备工作,包括:

  1. 为文件流对象和指定的磁盘文件建立关联,以便使文件流流向指定的磁盘文件。
  2. 指定文件的工作方式,如,该文件是作为输入文件还是输出文件,是ASCII文件还是二进制文件等。

以上工作可以通过两种不同的方法实现。

1) 调用文件流的成员函数open。如

ofstream outfile;  //定义ofstream类(输出文件流类)对象outfile
outfile.open("f1.dat",ios::out);  //使文件流与f1.dat文件建立关联

   
   
   
   
  • 1
  • 2
  • 3

第2行是调用输出文件流的成员函数open打开磁盘文件f1.dat,并指定它为输出文件, 文件流对象outfile将向磁盘文件f1.dat输出数据。ios::out是I/O模式的一种,表示以输出方式打开一个文件。或者简单地说,此时f1.dat是一个输出文件,接收从内存输出的数据。

调用成员函数open的一般形式为: 
文件流对象.open(磁盘文件名, 输入输出方式); 
磁盘文件名可以包括路径,如”c:/new/f1.dat”,如缺省路径,则默认为当前目录下的文件。

2) 在定义文件流对象时指定参数 
在声明文件流类时定义了带参数的构造函数,其中包含了打开磁盘文件的功能。因此,可以在定义文件流对象时指定参数,调用文件流类的构造函数来实现打开文件的功能。如 
ostream outfile("f1.dat",ios::out); 一般多用此形式,比较方便。作用与open函数相同。 
输入输出方式是在ios类中定义的,它们是枚举常量,有多种选择,见表13.6。


几点说明:

1) 新版本的I/O类库中不提供ios::nocreate和ios::noreplace。

2) 每一个打开的文件都有一个文件指针,该指针的初始位置由I/O方式指定,每次读写都从文件指针的当前位置开始。每读入一个字节,指针就后移一个字节。当文 件指针移到最后,就会遇到文件结束EOF(文件结束符也占一个字节,其值为-1),此时流对象的成员函数eof的值为非0值(一般设为1),表示文件结束 了。

3) 可以用“位或”运算符“|”对输入输出方式进行组合,如表13.6中最后3行所示那样。还可以举出下面一些例子: 
ios::in | ios:: noreplace //打开一个输入文件,若文件不存在则返回打开失败的信息 
ios::app | ios::nocreate //打开一个输出文件,在文件尾接着写数据,若文件不存在,则返回打开失败的信息 
ios::out l ios::noreplace //打开一个新文件作为输出文件,如果文件已存在则返回打开失败的信息 
ios::in l ios::out I ios::binary //打开一个二进制文件,可读可写

但不能组合互相排斥的方式,如 ios::nocreate l ios::noreplace。

4) 如果打开操作失败,open函数的返回值为0(假),如果是用调用构造函数的方式打开文件的,则流对象的值为0。可以据此测试打开是否成功。如

if(outfile.open("f1.bat", ios::app) ==0)
    cout <<"open error";

   
   
   
   
  • 1
  • 2
  • 3

if( !outfile.open("f1.bat", ios::app) )
    cout <<"open error";

   
   
   
   
  • 1
  • 2
  • 3

关闭文件

在对已打开的磁盘文件的读写操作完成后,应关闭该文件。关闭文件用成员函数close。如

outfile.close( );  //将输出文件流所关联的磁盘文件关闭

   
   
   
   
  • 1
  • 2

所谓关闭,实际上是解除该磁盘文件与文件流的关联,原来设置的工作方式也失效,这样,就不能再通过文件流对该文件进行输入或输出。此时可以将文件流与其他磁盘文件建立关联,通过文件流对新的文件进行输入或输出。如 
outfile.open(“f2.dat”,ios::app|ios::nocreate); 
此时文件流outfile与f2.dat建立关联,并指定了f2.dat的工作方式。

3.3对ASCII文件的操作

如果文件的每一个字节中均以ASCII代码形式存放数据,即一个字节存放一个字符,这个文件就是ASCII文件(或称字符文件)。程序可以从ASCII文件中读入若干个字符,也可以向它输出一些字符。 
1) 用流插入运算符“<<”和流提取运算符“>>”输入输出标准类型的数据。“<<”和“ >>”都在iostream中被重载为能用于ostream和istream类对象的标准类型的输入输出。由于ifstream和 ofstream分别是ostream和istream类的派生类;因此它们从ostream和istream类继承了公用的重载函数,所以在对磁盘文件的操作中,可以通过文件流对象和流插入运算符“<<”及 流提取运算符“>>”实现对磁盘 文件的读写,如同用cin、cout和<<、>>对标准设备进行读写一样。 
2) 用文件流的put、get、geiline等成员函数进行字符的输入输出,:用C++流成员函数put输出单个字符、C++ get()函数读入一个字符和C++ getline()函数读入一行字符。

#include 
#include 
#include 
#include 
using namespace std;

void main()
{ 
    char fileName[80];
    char buffer[255];

    cout << "请输入一个文件名: ";
    cin >> fileName;

    ofstream fout(fileName, ios::app);
    fout << "1111111111111111111\n";
    fout << "22222222222222222\n";
    cin.ignore(1,'\n');//在之前敲打文件名并输入回车的时候回车字符留在了缓冲区
    cin.getline(buffer, 255); //从键盘输入
    fout << buffer << "\n";
    fout.close();

    ifstream fin(fileName);
    cout << "Here's the the content of the file: \n";
    char ch;
    while (fin.get(ch))
        cout << ch;

    cout << "\n***End of file contents.***\n";
    fin.close();
    system("pause");
    return ;

}

   
   
   
   
  • 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

由于fstream类可以对文件同时进行读写操作,所以对它的对象进行初始话的时候一定要显式的指定mode和openprot参数。



3.4对二进制文件的操作

二进制文件不是以ASCII代码存放数据的,它将内存中数据存储形式不加转换地传送到磁盘文件,因此它又称为内存数据的映像文件。因为文件中的信息不是字符数据,而是字节中的二进制形式的信息,因此它又称为字节文件。 
对二进制文件的操作也需要先打开文件,用完后要关闭文件。在打开时要用ios::binary指定为以二进制形式传送和存储。二进制文件除了可以作为输入文件或输出文件外,还可以是既能输入又能输出的文件。这是和ASCII文件不同的地方。

对二进制文件的读写主要用istream和ostream类的成员函数read和write来实现。这两个成员函数的原型为

istream& read(char *buffer,int len);
ostream& write(const char * buffer,int len);

   
   
   
   
  • 1
  • 2
  • 3

字符指针buffer指向内存中一段存储空间。len是读写的字节数。调用的方式为:

a.write(p1,50);
b.read(p2,30);

   
   
   
   
  • 1
  • 2
  • 3

上面第一行中的a是输出文件流对象,write函数将字符指针p1所给出的地址开始的50个字节的内容不加转换地写到磁盘文件中。在第二行中,b是输入文 件流对象,read 函数从b所关联的磁盘文件中,读入30个字节(或遇EOF结束),存放在字符指针p2所指的一段空间内。

#define _CRT_SECURE_NO_WARNINGS

#include 
#include 
#include 
#include 
using namespace std;

class Teacher
{
public:

    Teacher(int age = 0,char *name = NULL)
    {
        int len = strlen(name);
        //m_name = new char[len+1];
        strncpy(m_name,name,len);
        m_name[len] = '\0';
        m_age = age;
    }
    Teacher(const Teacher & obj)
    {
        int len = strlen(obj.m_name);
        //m_name = new char[len + 1];
        strncpy(m_name, obj.m_name, len);
        m_name[len] = '\0';
        m_age = obj.m_age;
    }
    ~Teacher()
    {

    }
    void printT()
    {
        cout << "老师的年龄:" << m_age << endl << "老师的姓名:" << m_age << endl;
    }
protected:
private:
    int m_age;
    char m_name[64];
};

int main()
{ 
    char fileName[255] = "teacher123.dat";
    ofstream fout(fileName, ios::binary);
    if (!fout)
    {
        cout << "Unable to open " << fileName << " for writing.\n";
        fout.close();
        return(1);
    }

    Teacher t1(31, "31");
    Teacher t2(32, "32");
    fout.write((char *)&t1, sizeof Teacher);
    fout.write((char *)&t2, sizeof Teacher);
    fout.close();

    cout << "保存对象到二进制文件里成功!" << endl;

    ifstream fin(fileName, ios::binary);
    if (!fin)
    {
        cout << "Unable to open " << fileName << " for reading.\n";
        return (1);
    }
    Teacher tmp(100, "100");

    fin.read((char *)&tmp, sizeof Teacher);
    tmp.printT();

    fin.read((char *)&tmp, sizeof Teacher);
    tmp.printT();

    fin.close();
    system("pause");
    return 1;
}

   
   
   
   
  • 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
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80


编程实现以下数据输入/输出: 
(1)以左对齐方式输出整数,域宽为12。 
(2)以八进制、十进制、十六进制输入/输出整数。 
(3)实现浮点数的指数格式和定点格式的输入/输出,并指定精度。 
(4)把字符串读入字符型数组变量中,从键盘输入,要求输入串的空格也全部读入,以回车符结束。 
(5)将以上要求用流成员函数和操作符各做一遍。

成员函数方式

#define _CRT_SECURE_NO_WARNINGS

#include 
#include 
#include 
#include 
using namespace std;

/*编程实现以下数据输入/输出:
    (1)以左对齐方式输出整数,域宽为12。
    (2)以八进制、十进制、十六进制输入/输出整数。
    (3)实现浮点数的指数格式和定点格式的输入/输出,并指定精度。
    (4)把字符串读入字符型数组变量中,从键盘输入,要求输入串的空格也全部读入,以回车符结束。
    (5)将以上要求用流成员函数和操作符各做一遍。
*/

int main()
{ 

    int a = 10;
    cout.fill('*');
    cout.flags(ios_base::left);
    cout.width(12);
    cout << a << endl;

    cout.fill('*');
    cout.flags(ios::right);
    cout.width(12);
    cout << a << endl;

    cout.flags(ios::hex);
    cout << "十六进制:"<cout.flags(ios::dec);
    cout << "十进制:"<cout.flags(ios::oct);
    cout << "八进制:"<double f = 123.45678901234;

    cout.flags(ios::scientific);
    cout.precision(4);
    cout << "指数形式:" << f << endl;

    cout.flags(ios::fixed);
    cout.precision(4);
    cout << "定点形式:" << f << endl;

    char str[128];
    cin.get(str, 99);
    cout << "输入的数据是:"<"pause");
    return 1;
}
   
   
   
   
  • 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


格式控制符方式

#define _CRT_SECURE_NO_WARNINGS

#include 
#include 
#include 
#include 
using namespace std;

/*编程实现以下数据输入/输出:
    (1)以左对齐方式输出整数,域宽为12。
    (2)以八进制、十进制、十六进制输入/输出整数。
    (3)实现浮点数的指数格式和定点格式的输入/输出,并指定精度。
    (4)把字符串读入字符型数组变量中,从键盘输入,要求输入串的空格也全部读入,以回车符结束。
    (5)将以上要求用流成员函数和操作符各做一遍。
*/

int main()
{ 

    int a = 10;
    /*cout.fill('*');
    cout.flags(ios_base::left);
    cout.width(12);
    cout << a << endl;*/
    cout << setfill('*') << setiosflags(ios::left) << setw(12) << a << endl;

    /*cout.fill('*');
    cout.flags(ios::right);
    cout.width(12);
    cout << a << endl;*/
    cout << setfill('*') << setiosflags(ios::right) << setw(12) << a << endl;

    /*cout.flags(ios::hex);
    cout << "十六进制:"<
    cout << "十六进制:" << hex << a << endl;

    /*cout.flags(ios::dec);
    cout << "十进制:"<
    cout << "十进制:" </*cout.flags(ios::oct);
    cout << "八进制:"<
    cout << "八进制:" <double f = 123.45678901234;

    /*cout.flags(ios::scientific);
    cout.precision(4);
    cout << "指数形式:" << f << endl;*/
    cout << "指数形式:" << setiosflags(ios::scientific) << setprecision(4) << f << endl;


    /*cout.flags(ios::fixed);
    cout.precision(4);
    cout << "定点形式:" << f << endl;*/
    //resetiosflags(ios::scientific);必须写在cout的链式编程流中,单独写成语句并没有实际效果。
    cout << "定点形式:" << resetiosflags(ios::scientific)<< setiosflags(ios::fixed) << setprecision(4) << dec << f << endl;


    char str[128];
    cin.get(str, 99);
    cout << "输入的数据是:"<"pause");
    return 1;
}

   
   
   
   
  • 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


2编写一程序,将两个文件合并成一个文件。

#define _CRT_SECURE_NO_WARNINGS

#include 
#include 
#include 
#include 
using namespace std;


int main()
{ 
    char ifile1_name[16] = "1.cpp";
    char ifile2_name[16] = "2.cpp";
    char ofile_name[16] = "3.cpp";

    char tmp_buf[1024];

    ifstream ifile1(ifile1_name);
    ifstream ifile2(ifile2_name);

    ofstream ofile(ofile_name);

    while (!ifile1.eof())
    {
        ifile1.getline(tmp_buf, 1023);
        ofile << tmp_buf << endl;
    }

    while (!ifile2.eof())
    {
        ifile2.getline(tmp_buf, 1023);
        ofile << tmp_buf << endl;
    }

    ifile1.close();
    ifile2.close();
    ofile.close();

    system("pause");
    return 1;
}

   
   
   
   
  • 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

3编写一程序,统计一篇英文文章中单词的个数与行数。

#define _CRT_SECURE_NO_WARNINGS

#include 
#include 
#include 
#include 
using namespace std;

bool is_alph(char c)
{
    return ((c >= 'a'&&c <= 'z') || (c >= 'A'&&c <= 'Z'));
}

int main()
{ 
    char ifile_name[16] = "1.cpp";
    char tmp_buf[1024];
    int words_cnt = 0;
    int rows_cnt = 0;
    bool inword = false;

    ifstream ifile(ifile_name);

    int  i = 0;
    while (!ifile.eof())
    {
        ifile.getline(tmp_buf, 1023);
        rows_cnt++;
        i = 0;
        while (tmp_buf[i] != '\0')
        {
            if (!is_alph(tmp_buf[i]))//遇到非字母字符标记该字符不属于单词部分
            {
                inword = false;
            }
            else if (is_alph(tmp_buf[i])&&inword == false)//如果当前字符属于字母,且前一个字符不属于字母,表示有新单词产生,单词数加一,并把当前字母标记为属于单词的部分
            {
                words_cnt++;
                inword = true;
            }
            i++;
        }
    }

    cout << "rows= " << rows_cnt << endl;
    cout << "words= " << words_cnt << endl;
    ifile.close();

    system("pause");
    return 1;
}

   
   
   
   
  • 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

4编写一程序,将C++源程序每行前加上行号与一个空格。

#define _CRT_SECURE_NO_WARNINGS

#include 
#include 
#include 
#include 
using namespace std;

bool is_alph(char c)
{
    return ((c >= 'a'&&c <= 'z') || (c >= 'A'&&c <= 'Z'));
}

int main()
{ 
    char ifile_name[16] = "1.cpp";
    char ofile_name[16] = "4.cpp";
    char tmp_buf[1024];


    ifstream ifile(ifile_name);
    ofstream ofile(ofile_name);

    int  i = 0;
    while (!ifile.eof())
    {
        ofile << ++i << ":";
        ifile.getline(tmp_buf, 1023);
        ofile << tmp_buf << endl;   
    }
    ifile.close();
    ofile.close();

    system("pause");
    return 1;
}

   
   
   
   
  • 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

5编写一程序,输出 ASCII码值从20到127的ASCII码字符表,格式为每行10个。

#define _CRT_SECURE_NO_WARNINGS

#include 
#include 
#include 
#include 
using namespace std;

bool is_alph(char c)
{
    return ((c >= 'a'&&c <= 'z') || (c >= 'A'&&c <= 'Z'));
}

int main()
{ 
    int i = 20;
    int cnt = 0;
    for (i = 20; i <= 127; i++)
    {
        cout << static_cast<char>(i) << "\t";
        cnt++;
        if (cnt % 10 == 0)
        {
            cout << endl;
        }
    }
    cout << endl;
    system("pause");
    return 1;
}

你可能感兴趣的:(c++基础)