Input/output with files

• ofstream: Clasă stream pentru scrierea în fișiere
• ifstream: Clasă stream pentru citirea din fișiere
• fstream: Clasă stream petru operții de citire/scriere din/în fișiere.

// operații de bază cu fișiere
#include <iostream>
#include <fstream>
using namespace std;

int main () {
  ofstream fisierul_meu;
  fisierul_meu.open ("exemplu.txt");
  fisierul_meu << "Scriem acest text intr-un fisier.\n";
  fisierul_meu.close();
  return 0;
}

[fișierul exemplu.txt]
Scriem acest text intr-un fisier.

Deschiderea unui fișier

1
2

ofstream fisierul_meu;
fisierul_meu.open ("exemplu.bin", ios::out | ios::app | ios::binary);

1

ofstream fisierul_meu ("exemplu.bin", ios::out | ios::app | ios::binary);

1

if (fisierul_meu.is_open()) { /* ok, continuam cu scrierea */ }

Închiderea unui fișier

1

fișierul_meu.close();

Fișiere text

// scrierea într-un fișier text
#include <iostream>
#include <fstream>
using namespace std;

int main () {
  ofstream fisierul_meu ("exemplu.txt");
  if (fisierul_meu.is_open())
  {
    fisierul_meu << "Aceasta este o linie.\n";
    fisierul_meu << "Aceasta este alta linie.\n";
    fisierul_meu.close();
  }
  else cout << "Nu s-a putut deschide fisierul!";
  return 0;
}

[fișierul exemplu.txt]
Aceasta este o linie.
Aceasta este alta linie.

// citirea unui fișier text
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main () {
  string linie;
  ifstream fisierul_meu ("exemplu.txt");
  if (fisierul_meu.is_open())
  {
    while ( getline (fisierul_meu,linie) )
    {
      cout << linie << '\n';
    }
    fisierul_meu.close();
  }

  else cout << "Nu se poate deschide fișierul"; 

  return 0;
}

Aceasta este o linie.
Aceasta este alta linie.  

Verificarea indicatorilor de stare

bad()

Returnează true dacă o operație de citire sau scriere eșuează. De exemplu, dacă încercăm să scriem într-un fișier care nu este deschis pentru scriere sau dacă nu mai este spațiu disponibil pentru scriere.

fail()

Returnează true în aceleași situații ca bad(), dar și atunci când apare o eroare de format, ca de exemplu la întâlnirea unui caracter alfabetic într-o operație care necesită citirea unui număr întreg.

eof()

Returnează true dacă s-a ajuns la sfârșitul unui fișier deschis pentru citire.

good()

Este cel mai generic indicator de stare: returnează false în aceleași situații în care apelul oricăreia dintre funcțiile anterioare ar returna true. Să observăm că funcțiile good și bad nu sunt chiar opuse (good verifică mai mulți indicatori de stare deodată).

get and put stream positioning

tellg() and tellp()

seekg() and seekp()

// obtaining file size
#include <iostream>
#include <fstream>
using namespace std;

int main () {
  streampos begin,end;
  ifstream myfile ("example.bin", ios::binary);
  begin = myfile.tellg();
  myfile.seekg (0, ios::end);
  end = myfile.tellg();
  myfile.close();
  cout << "size is: " << (end-begin) << " bytes.\n";
  return 0;
}

size is: 40 bytes.

1

streampos size;

Binary files

// reading an entire binary file
#include <iostream>
#include <fstream>
using namespace std;

int main () {
  streampos size;
  char * memblock;

  ifstream file ("example.bin", ios::in|ios::binary|ios::ate);
  if (file.is_open())
  {
    size = file.tellg();
    memblock = new char [size];
    file.seekg (0, ios::beg);
    file.read (memblock, size);
    file.close();

    cout << "the entire file content is in memory";

    delete[] memblock;
  }
  else cout << "Unable to open file";
  return 0;
}

the entire file content is in memory

1

memblock = new char[size];

1
2
3

file.seekg (0, ios::beg);
file.read (memblock, size);
file.close();

Buffers and Synchronization

• When the file is closed: before closing a file, all buffers that have not yet been flushed are synchronized and all pending data is written or read to the physical medium.
• When the buffer is full: Buffers have a certain size. When the buffer is full it is automatically synchronized.
• Explicitly, with manipulators: When certain manipulators are used on streams, an explicit synchronization takes place. These manipulators are: flush and endl.
• Explicitly, with member function sync(): Calling the stream's member function sync() causes an immediate synchronization. This function returns an int value equal to -1 if the stream has no associated buffer or in case of failure. Otherwise (if the stream buffer was successfully synchronized) it returns 0.