C++ ifstream ofstream

C++文件读写详解（ofstream,ifstream,fstream）

 

 

1． 概述：

Input/Output library

C++输入输出流的继承关系如图：

1.  #include   

2.  ofstream         //文件写操作 内存写入存储设备   

3.  ifstream         //文件读操作，存储设备读区到内存中  

4.  fstream          //读写操作，对打开的文件可进行读写操作

2． ofstream

Ø  头文件

#include

 

Ø  继承关系

Ø  功能

文件写操作，内存写入存储设备

Ø  open（）函数

成员函数open（）实现打开文件的操作，从而将数据流和文件进行关联

几种比较常用的打开方式:

1)    

以输出的方式打开文件，若文件不存在建立文件，若文件存在将文件长度置为0

fstream fout;
fout.open("D:/1.txt",ofstream::out|ofstream::trunc);//不能用||
if (!fout.is_open())
{
   return;//打开失败就返回
}

2)   以输出的方式打开文件，如果没有文件，那么生成空文件；如果有文件，那么清空该文件，写文件的时候是文件指针指向文件末尾（这个是写文件故将文件清空了）（）
fout.open("D:/1.txt",ofstream::out|ofstream::ate);//不能用||（若是in则表示将文件的指针移动到文件末尾）
if (!fout.is_open())
{
return;
}

3)    

以输出方式打开文件，如果没有文件，那么生成空文件；如果有文件，那么在文件尾追加。写文件的时候是文件指针指向文件末尾
fout.open("D:/1.txt",ofstream::out|ofstream::app);//不能用||
if (!fout.is_open())
{
  return;
}

 

打开文件的方式在类ios(是所有流式I/O类的基类)中定义，常用的值如下：  
ios::app：　　　以追加的方式打开文件  
ios::ate：　　　文件打开后定位到文件尾，ios:app就包含有此属性  
ios::binary：　以二进制方式打开文件，缺省的方式是文本方式。两种方式的区别见前文  
ios::in：　　　 文件以输入方式打开（文件数据输入到内存）  
ios::out：　　　文件以输出方式打开（内存数据输出到文件）  
ios::nocreate： 不建立文件，所以文件不存在时打开失败  
ios::noreplace：不覆盖文件，所以打开文件时如果文件存在失败  
ios::trunc：　　如果文件存在，把文件长度设为0

Ø  示例程序

 

#include       //std::ofstream

 

         int main () {

 

        std::ofstream ofs;

        ofs.open ("D:/1test.txt",std::ofstream::out | std::ofstream::app);

 

        ofs << "more lorem ipsum"<

 

        ofs.close();

 

        return0;

 

3． ifstream

Ø  继承关系

Ø  头文件

#include

Ø  示例程序

 

// print the content of a text file.

#include      // std::cout

#include       // std::ifstream

int main () {

  std::ifstream ifs;

  ifs.open ("test.txt", std::ifstream::in);

  char c = ifs.get();

  while (ifs.good()) {

    std::cout << c;

    c = ifs.get();

  }

  ifs.close();

  return 0;

}

 

4． 二进制文件

1)     在二进制文件中，使用<< 和>>，以及函数（如getline）来操作符输入和输出数据，没有什么实际意义，虽然它们是符合语法的。

2)     文件流包括两个为顺序读写数据特殊设计的成员函数：write 和 read。第一个函数 (write) 是ostream 的一个成员函数，都是被ofstream所继承。而read 是istream 的一个成员函数，被ifstream 所继承。类 fstream 的对象同时拥有这两个函数。

3)     它们的原型是：

write ( char * buffer, streamsize size );

read ( char * buffer,streamsize size );

4)     它们的原型是：

这里 buffer 是一块内存的地址，用来存储或读出数据。参数size 是一个整数值，表示要从缓存（buffer）中读出或写入的字符数。

5)   示例程序

例1

写程序

    std::ofstreamoutfile ("D:/new.txt",std::ofstream::out|std::ofstream::binary);//写入文件

    if (outfile.is_open())

    {

        char buf[1024]={0};

        strcpy(buf,"huanghao2015082401");

        int n=strlen(buf);

        cout<

        outfile.write(buf,strlen(buf));

    }

 

读程序

// reading binary file 

#include  

#include  

 

const char * filename = "D:/new.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+1]; 

                  memset(buffer,0,size+1);

    in.read(buffer, size); 

    in.close(); 

 

    cout<< "the complete file is in abuffer"; 

 

    delete[] buffer; 

    return 0; 

} 

//运行结果： 

The complete file is in a buffer

 

 

例2

读程序

// read a file into memory

#include      // std::cout

#include       // std::ifstream

 

int main () {

 

 std::ifstream is ("test.txt", std::ifstream::binary);

  if (is) {

    // get length of file:

   is.seekg (0, is.end);

    int length = is.tellg();

   is.seekg (0, is.beg);

 

char * buffer = new char [length+1];

memset(buffer,0,length+1);

 

 

   std::cout << "Reading" << length<< "characters... ";

    // read data as a block:

   is.read (buffer,length);

 

    if (is)

     std::cout << "allcharacters read successfully.";

    else

     std::cout << "error:only " << is.gcount()<< " could beread";

   is.close();

 

    // ...buffer contains the entire file...

cout<

cout<

cout<

    delete[] buffer;

  }

  return 0;

}

 

例3

写程序（写结构）

void write03()

{

  struct record { 

      char name[10]; 

      int age; 

  };

  struct record array[2]= {{"Ken", 24}, {"Knuth", 28}};

  std::ofstreamoutfile ("D:/new.txt",std::ofstream::out|std::ofstream::binary);//写入文件

  if (outfile.is_open())

  {

      outfile.write((char*)array,sizeof(record)*2);

  }

}

 

读程序（读结构体）

void read03()

{

 

  struct record { 

      char name[10]; 

      int age; 

  }; 

 

 

  struct record array[2];

 

  std::ifstreaminfile ("D:/new.txt",std::ifstream::binary);//读取文件

 

 

  // get size of file

  infile.seekg(0,infile.end);//让读取文件的指针跳转到文件末尾 意思是离文件end处为0

  long size = infile.tellg();//计算出文件的字符串长度

  infile.seekg(0);//将文件指针指向文件开始位置

 

  infile.read((char*)array,size);

 

  printf("Name1: %s\tAge1: %d\n", array[0].name, array[0].age); 

  printf("Name2: %s\tAge2: %d\n", array[1].name, array[1].age); 

 

}

例4

写程序（写整数）

 void write04()

{

  std::ofstreamfout("D:/a.dat",std::ios::binary);

 

  int nNum = 20;

  std::stringstr("Hello, world");

 

  fout.write((char*)&nNum, sizeof(int));

  fout.write(str.c_str(),sizeof(char) *(str.size()));

 

  fout.close();

}

读程序（读整数）

void read04()

{

  std::ifstreamfin("D:/a.dat", std::ios::binary);

 

  int nNum;

  char szBuf[256] = {0};

 

  fin.read((char*)&nNum, sizeof(int));

  fin.read(szBuf,sizeof(char) *256);

 

  std::cout<< "int = " << nNum<< std::endl;

  std::cout<< "str = " << szBuf<< std::endl;

 

  fin.close();

}

 

5． 按行读取

示例程序

例1（用cin  标准输入）

// istream::getline example

#include      // std::cin, std::cout

 

int main () {

  char name[256], title[256];

 

 std::cout << "Please,enter your name: ";

 std::cin.getline (name,256);

 

 std::cout << "Please,enter your favourite movie: ";

 std::cin.getline (title,256);

 

 std::cout << name << "'s favourite movie is " << title;

 

  return 0;

}

例2（ifstream 按行读取）

int getline2()

{

    ifstreamifs;

    ifs.open("D:/test.ini",ifstream::in);

    if (ifs.is_open())

    {

        char data[256]={0};

 

        while (!ifs.eof())

        {

            ifs.getline(data,256);

            cout<

            memset(data,0,256);

        }

    }

    return 0;

}

 

 

6． 关闭（close）

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