1. C++中各种输入输出函数总结

与输入输出流操作相关的类关系

image

2. 键盘输入输出函数

2.1. scanf函数

• 头文件

  #include"stdio.h"
  

• 原型：int scanf(const char * restrict format,....);

• 入口参数：第一个参数是格式字符串，指定输入格式，...格式化后的字符串存取地址

• 返回值：返回值类型为int,如果读取到文件结束则返回EOF,EOF为Ctrl+z或者Ctrl+d.其他情况返回int型数字例如：int res = scanf("%d %d",&a,&b);如果a,b都读取成功，则返回2；如果a,b只读取成功了一个，则返回1；如果a,b都没有读取成功，则返回0.

• 说明：scanf()函数是C语言库中的函数，但由于C++的向下兼容性，所以在C++中也可以使用此函数。次函数是从标准输入流stdio（一般是键盘输入）中读取数据，并将其按照指定格式输入到制定地址。

• 用例：

  #include <stdio.h>
  #include <iostream>
  using namespace std;
  
  int main()
  {
      int a,b;
      scanf("%d %d",&a,&b); //注意此处输入的格式，两个输入数字之间要以空格分隔开来。
      printf("%d %d",a,b);
  }
  

2.2. cin()类（此类命名空间都在std中，无需添加头文件）。

• 标准流对象
  • 输入流对象：cin:用于从键盘读取数据，也可以重定向从文件读取数据
  • 输出流对象：cout：输出数据到屏幕上，也可以重定向输出到文件中
  • 标准错误：cerr ：默认与cout相同
  • 标准错误：clog：默认与cout相同
• 判断输入流结束

  int x;
  while(cin>>x){
  }
  

  • 如果从文件输入，读到文件结尾算结束
  • 如果从键盘输入，则在单独一行输入Ctrl+Z代表输入流结束

2.2.1. cin>> 函数

• 说明：当我们从键盘输入时，有一个缓冲区，当输入结束时会将所输入的数据存到缓冲区。而cin>>的作用就是从缓冲区读数据，所以当缓冲区数据本来就有残留时，会出现读取出错的问题。值得一提的是：cin函数遇到空格、TAB、换行时读取结束。
• 用例：

  1. 输入一个字符串

     #include <iostream>
     using namespace std;
     void main ()
     {
     　　char a[10];
     　　cin>>a;
     　　cout<<a<<endl;
     }
     

     输入：aaabbbccc
     输出：aaabbbccc
     输入：aaa bbb ccc
     输出：aaa

  2. 输入一个数字

     #include <iostream>
     using namespace std;
     void main ()
     {
         int a,b;
         cin>>a>>b;
         cout<<a+b<<endl;
     }
     

     输入：1回车2回车
     输出：3

2.2.2. cin.get()函数

• 该函数有三种形式，分别是char ch = cin.get(), cin.get(char ch), cin.get(array,length)
cin.get() 和 cin.get(char ch)的用法
  这两个函数功能基本一样，都是读取缓冲区的一个字符，遇到换行符结束，但是这两个函数都不会丢弃缓冲区里边的空格和换行符。char ch = cin.get(), cin.get(char ch)这两句可得到相同的结果。
  用例：

  #include <iostream>
  using namespace std;
  void main()
  {
      char ch1,ch2;
      cin.get(ch1);
      ch2 = cin.get();
  
      cout<<ch1<<endl;
      cout<<ch2<<endl;
  }  
  

  输入：a换行
  输出：a

  2. cin.get(array,length)
     • 这个函数是从缓冲区读取字符串，其中array是字符串接受地址，length-1是字符串长度，因为最后一个字符必须存 储'\0'结束符，所以此函数只能接受length-1个字符。
     • 用例：

     #include <iostream>
     using namespace std;
     void main()
     {
         char ch[5];
         cin.get(ch,5);
         cou<<ch<<endl;
     }
     

     输入：abcdefghi
     输出：abcd

2.2.3. cin.getline函数

• 原型：
  • cin.getline(char * buf,int length)：接收一个长度为length-1的字符串，包括空格，遇到换行结束。
  • cin.getline(char * buf,int length,char delim)：接收一个长度为length-1的字符串，包括空格，或者读到delim字符或遇换行符结束。

#include<iostream>
using namespace std;
int main()
{
    char ch[10];
    cin.getline(ch,5);
    cout<<ch<<endl;
    return 0;
}

输入：aaaaaaaa
输出：aaaa

• 注意：
  • 两个函数都会自动在buf中读入数据的结尾添加'\0’。
  • ‘\n’和delim都不会被读入buf,但是会被从输入流中取走，
  • 如果输入流中‘\n’或delim之前的字符达到或者超过bufsize个，就导致读入出错，虽然本次读入完成，但是以后读入就会失败

2.2.4. 补充说明

• bool eof();判断输入流是否结束
• int peek();返回下一个字符，但是不从流中去掉
• istream & putback(char c);将字符ch放回到输入流
• istream & ignore(int nCount=1,int delim =EOF);从流中删除最多nCount个字符，遇到EOF时结束

2.2.5. 流操作算子

• 使用流操作算子需要包含头文件#include<iomanip>
• 整数流的基数：流操作算子：dec,oct,hex,setbase

int n = 10;
cout << n << endl;
cout << hex << n << endl;
cout << dec << n << endl;
cout << oct << n << endl;

输出：
10
a
10
12

• 浮点数精度流操作算子：precision,setprecision
  • 指定输入浮点数的有效位数（非定点方式输出）
  • 指定输出浮点数的小数后的有效位数（定点防暑输出）
  • 注意：
    • 默认为非定点输出
    • 设置定点方式输出cout << setiosflags(ios::fixed) << setprecision(6)<<
    • 修改为非顶点方式输出cout << resetiosflags(ios::fixed) << setprecision(6)<<

cout.precision(5)  //是成员函数
cout << setprecision(5)<< 5.23;  //是流操作算子

• 设置域宽:setw,width
  • 宽度设置有效性是一次，每次读入和输出都要设置宽度
  • 使用方式 cin >> setw(4)或者cin.width(5)。cout << setw(4)或者cout.width(5)
• 用户自定义的流操作算子

ostream & tab(ostream & output){
  return output << '\t' ;
}
cout << "aa" << tab << "bb" << endl;

输出： aa bb

2.2.6. 二进制文件读写

二进制读文件：

• 函数原型：istream & read(char * s,long n);
• 说明：将文件读指针指向的地方的n个字节内容，读入到内存地址s，然后将读指针向后移动n字节

二进制写入文件

• 函数原型：istream & write(const char * s,long n)
• 说明：将内存地址s处的n个字节内容，写入到文件中写指针指向的位置，然后将文件写指针向后移动n字节

例程

#include"iostream"
#include"fstream"
using namespace std;
void test100() {
    ofstream fout("some.txt", ios::out | ios::binary);
    int x = 120;
    fout.write((const char *)(&x), sizeof(int));
    fout.close();
    ifstream fin("some.txt", ios::in | ios::binary);
    int y;
    fin.read((char *)& y, sizeof(int));
    fin.close();
    cout << y << endl;
}

2.3. getline()函数

原型：

• ssize_t getline(char **lineptr,size_t *n,FILE *stream);(在Ｃ语言的GCC扩展定义中)

• getline(cin,string s);（在C++中）

• 说明：getline不是C语言的库函数，而是GCC的扩展定义或者C++库函数，在Ｃ语言中和C++中的使用是不同的.

• 用例１：（在C++中,应包含头文件<string>，读取字符串包含空格，遇到换行结束，不包括换行）

例程：

＃include <iostream>
using namespace std;
int main()
{
    string s;
    getline(cin,s);
    cout<<s<<endl;
    return 0;
}

输入：abcdefgh换行
输出：abcdefgh

2.4. gets()函数

原型：

• char *gets(char *buffer);
• 入口参数：从缓冲区读取字符串后的写入地址
• 返回值：读取成功后返回与入口参数buffer相同的地址。读取错误返回NULL。
• 头文件：<string>
• 说明:接收输入的字符串，没有上限，但是要保证buffer足够大，以换行结束，并将换行符转化为'\0'。
• 用例：

#include<iostream>
#include<string>
using namespace std;
int main()
{
　　char ch[10];
　　gets(ch);
　　cout<<ch<<endl;
　　return 0;
}

输入：abcdefg回车
输出：abcdefg

2.5. getchar()函数

• 原型：int getchar(void);
• 返回值：读取成功返回用户输入的ASCII码，读取失败返回EOF.
• 头文件：<string>或者<stdio.h>
• 说明：接收一个字符的输入，包含空格，遇到换行符结束。

  #include<iostream>
  #include<string>
  using namespace std;
  int main()
  {
  　　char ch;
  　　ch = getchar();
  　　cout<<ch<<endl;
  　　return 0;
  }
  

  输入：abc回车
  输出：a

3. 文本读写函数

image

3.1. C++文件读写操作

使用方式

#include "fstream"
ofstream ofile    //文件写操作，内存写入存储设备
ifstream ifile    //文件读操作，存储设备读入内存
fstream  file    //文件读写操作
ofile.open("filename",mode)        //打开文件以及打开模式
if(!ofile){    //判断文件是否打开成功
  cout << "file open error!" << endl;
}

3.1.1. 打开文件

文件操作通过成员函数open()实现打开文件

//open
public member function  
void open ( const char * filename,  
            ios_base::openmode mode = ios_base::in | ios_base::out );  
void open(const wchar_t *_Filename,  
        ios_base::openmode mode= ios_base::in | ios_base::out,  
        int prot = ios_base::_Openprot)；

• 参数：
  filename:操作文件名
  mode:打开文件的方式
  prot:打开文件的属性 //基本很少用到，在查看资料时，发现有两种方式
  打开文件的方式在ios类(所以流式I/O的基类)中定义，有如下几种方式：

ios::in     为输入(读)而打开文件
ios::out    为输出(写)而打开文件
ios::ate    初始位置：文件尾
ios::app    所有输出附加在文件末尾
ios::trunc  如果文件已存在则先删除该文件
ios::binary 二进制方式

这些方式是能够进行组合使用的，以“或”运算（“|”）的方式：例如

ofstream out;  
out.open("Hello.txt", ios::in|ios::out|ios::binary)                 //根据自己需要进行适当的选取  

打开文件的属性同样在ios类中也有定义：
0 普通文件，打开操作
1 只读文件
2 隐含文件
4 系统文件
对于文件的属性也可以使用“或”运算和“+”进行组合使用，这里就不做说明了。
很多程序中，可能会碰到ofstream out("Hello.txt"), ifstream in("..."),fstream foi("...")这样的的使用，并没有显式的去调用open（）函数就进行文件的操作，直接调用了其默认的打开方式，因为在stream类的构造函数中调用了open()函数,并拥有同样的构造函数，所以在这里可以直接使用流对象进行文件的操作，默认方式如下：

ofstream out("...", ios::out);  
ifstream in("...", ios::in);  
fstream foi("...", ios::in|ios::out);  

当使用默认方式进行对文件的操作时，你可以使用成员函数is_open()对文件是否打开进行验证

3.1.2. 关闭文件

当文件读写操作完成之后，我们必须将文件关闭以使文件重新变为可访问的。成员函数close()，它负责将缓存中的数据排放出来并关闭文件。这个函数一旦被调用，原先的流对象就可以被用来打开其它的文件了，这个文件也就可以重新被其它的进程所访问了。为防止流对象被销毁时还联系着打开的文件，析构函数将会自动调用关闭函数close。

3.1.3. 文件的读写

类ofstream, ifstream 和fstream 是分别从ostream, istream 和iostream 中引申而来的。这就是为什么 fstream 的对象可以使用其父类的成员来访问数据。
一般来说，我们将使用这些类与同控制台(console)交互同样的成员函数(cin 和 cout)来进行输入输出。如下面的例题所示，我们使用重载的插入操作符<<：

// writing on a text file
#include <fiostream.h>
int main () {
    ofstream out("out.txt");
    if (out.is_open())
    {
         out << "This is a line.\n";
         out << "This is another line.\n";
         out.close();
    }
    return 0;
}
//结果: 在out.txt中写入：
This is a line.
This is another line

// reading binary file
#include <iostream>
#include <fstream.h>
const char * filename = "test.txt";
int main () {
    char * buffer;
    long size;
    ifstream in (filename, ios::in|ios::binary|ios::ate);
    size = in.tellg();
    in.seekg (0, ios::beg);
    buffer = new char [size];
    in.read (buffer, size);
    in.close();
    cout << "the complete file is in a buffer";
    delete[] buffer;
    return 0;
}
//运行结果：
The complete file is in a buffer

3.1.4. 文件的读写指针

ofstream fout("a1.out",ios::app);  //以添加方式打开
long location = fout.tellp();    //取得写指针位置
location = 10L;
fout.seekp(location);          //将写指针移动到第十个字节处
fout.seekg(location);          //将读指针移动到第十个字节处
fout.seekp(location,ios:beg);  //从头数location
fout.seekp(location,ios::cur); //从当前位置数location
fout.seekp(location,ios::end); //从尾部数location

3.1.5. 用流迭代器读取写入文件

#include "vector"
#include "string"
#include "fstream"
#include "iterator"
void practice10_29() {
    ifstream files;
    vector<string> Str;
    files.open("./hello.txt");          //打开文件
    istream_iterator<string> in_iter(files);        //定义文件输出流
    if (files.is_open())                //如果文件打开成功
        while (!files.eof()) {          //如果输入流没有到末尾
            Str.push_back(*in_iter++);  //读取输入流存储到内存中
        }
    else {
        cout << "open file failed" << endl;
    }
    files.close();
    print(Str);
}

void test10_28() {
    vector<string> Str = { "fox","red","banoria" ,"over","begin","man","hello","promise" };
    ofstream ofile;
    ofile.open("./hello.txt",ios::app);
    auto sp = Str.begin();
    ostream_iterator<string> out_iter(ofile," ");
    if(ofile.is_open())
        copy(Str.begin(), Str.end(), out_iter);
    ofile.close();
}

4. 注意：

• Linux,Unix下的换行符'\n' (ASCII码：0X0A)
• Window下的换行符'\r\n'(ASCII码：0X0D0A,endl是’\n‘)
  • window下不以二进制文件读写文件，读入文件所有\r\n会被自动处理为\n，写入文件单独的\n会被自动添加\r
• MacOS下的换行符'\r' (ASCII码：0x0d)