Vordefinierte Klassen: Die C++ I/O-Bibliothek

        Die Ein/Ausgabe ist nicht in der Sprache definiert, sondern Bestandteil der Standardbibliothek.

ANSI C C++

Stream #include <stdio.h> #include <iostream.h>

I/O printf(...) cout << X;

scanf(...) cin >> X;

File #include <stdio.h> #include <fstream.h>

I/O FILE out; ofstream out("o"); out=fopen("o","w");

fprintf(out, ...) out << X;

FILE inp; ifstream inp("i"); inp=fopen("i","r");

fscanf(inp, ...) inp >> X;

String #include <stdio.h> #include <strstream.h>

I/O sprintf(...) char t[80]; ostrstream otxt(t,80); otxt << X;

sscanf(...) istrstream itxt(t,80); itxt >> X;

Stream-Ausgabe

  Drei Output-Stream-Objekte sind definiert:

     

cout: Standardausgabe.

cerr: Ungepufferte Fehlerausgabe.

clog: Gepufferte Fehlerausgabe.

Die Ausgabe erfolgt mit dem Einfügeoperator <<, der für die Standardtypen vordefinert ist. Z. B.:    

   ostream& operator<<(char);
   ostream& operator<<(unsigned char);
   ostream& operator<<(const char*);
   ostream& operator<<(int); 
   ostream& operator<<(long); 
   ostream& operator<<(double);
   ostream& operator<<(float);
   ostream& operator<<(unsigned int);
   ostream& operator<<(unsigned long);
   ostream& operator<<(void*);
   ostream& operator<<(short);
   ostream& operator<<(unsigned short)

Für formatierte Ausgabe stehen sog. Manipulatoren   zur Verfügung, die ebenfalls durch << in den Ausgabe-Stream eingefügt werden. Dazu ``#include <iomanip.h>''.

Manipulator Bedeutung / Benutzung

hex Hex-Ausgabe cout << hex << 17;

dec Dezimal-Ausgabe cout << dec << i;

oct Oktal-Ausgabe cout << oct << 100;

endl Newline und Flush cout << endl;

flush Flush cout << flush;

setw(int) Feldweite cout << setw(8);

setfill(int) Füllbuchstabe cout << setfill('.');

setiosflags(long) Setzen von Flags cout << setiosflags(ios::right);

resetiosflags(long) Rücksetzen von Flags cout << resetiosflags(ios::dec);

setprecision(int) Fließpunktpräzision cout << setprecision(6);

Flag Bedeutung

ios::left Linksbündige Ausgabe

ios::right Rechtsbündige Ausgabe

ios::scientific Wissenschaftliches Float-Format z.B. -1.23E+04

ios::fixed Festpunkformat für Float z.B. 123.45

Beispiel:

#include <iostream.h>
#include <iomanip.h>
struct buch
{ char *kapitel;
  int seite;
} inhalt[4] = { "Einleitung", 1,
                "Grundlagen", 11,
                "Neuigkeiten", 102,
                "Zusammenfassung",102
              };
void druckeinhalt()
{ cout << setfill('.');
  for (int kap=0; kap<4 ; kap++)
  { cout << setiosflags(ios::left) << setw(20);
    cout << inhalt[kap].kapitel;
    cout << resetiosflags(ios::left) << setw(4);
    cout << inhalt[kap].seite << endl;
  }
}

liefert die Ausgabe:

    Einleitung.............1
    Grundlagen............11
    Neuigkeiten..........102
    Zusammenfassung......102

Selbstdefinierte Einfügeoperatoren <<    

Die erforderliche Signatur ist

ostream& operator << (ostream& OS, classtype& E)

oder

ostream& operator << (ostream& OS, classtype E)

Beispiel:

#include <iostream.h>
class date 
{   int day, month, year;
  public:
    date(int d, int m, int y) 
        : day(d), month(m), year(y) {};
    friend ostream& operator << (ostream&, date&);
};

ostream& operator << (ostream& OS, date& D)
{ OS << D.day << '.' << D.month << '.' << D.year;
  return OS;
}

int main(void) /*  */
{   date today(3,5,1993);   
    cout << today;
}

Stream-Eingabe

  Ein Input-Stream-Objekt ist definiert:

cin: Standardeingabe.

Die Eingabe erfolgt mit dem Extraktionsoperator >>, der für die Standardtypen vordefiniert ist.      

Der Extraktionsoperator betrachtet ``Whitespace'' (Leerzeichen, Tabulatoren, Zeilenende) als Abgrenzung zwischen Eingabesymbolen und nicht als eigenständige Symbole.

Das Programm

   char z;
   while (cin >> z)
      cout << z << ", "

erzeugt aus der Eingabe

     ab
      c

die Ausgabe

    a, b, c,

#include <iostream.h>
#include <string.h>
const int puffergroesse = 28;
char puffer[puffergroesse];
int main(void)
{ int anzahl = 0, max = 1, laenge;
  char laengstes[puffergroesse];
  while (cin >> puffer)
  { laenge = strlen(puffer);
    anzahl++;
    if (laenge > max)
    { max = laenge;
      strcpy(laengstes, puffer);
    } /* if */       
  } /* while */
  cout << "Anzahl der Woerter: " << anzahl << endl;
  cout << "Laengstes Wort: " << laengstes << endl;
} /* main */

ergibt mit der Eingabe

Wo immer im Mittelalter innerhalb der von Deutschen
besiedelten Landstriche sich Zuege feinerer 
Gesittung und Geselligkeit zeigten, stammten sie
aus dem Morgenland oder aus dem Erbe der roemischen
Kultur.

die Ausgabe

Anzahl der Woerter: 29
Laengstes Wort: Geselligkeit

 

Manipulator Bedeutung / Benutzung

hex Hex-Eingabe cin >> hex >> i;

dec Dezimal-Eingabe cin >> dec >> i;

oct Oktal-Eingabe cin >> oct >> i;

setw(int) Feldweite cin >> setw(24);

setfill(int) Füllbuchstabe cin >> setfill(' ');

setiosflags(long) Setzen von Flags cin >> setiosflags(ios::fixed);

resetiosflags(long) Rücksetzen von Flags cin >> resetiosflags(ios::dec);

setprecision(int) Fließpunktpräzision cin >> setprecision(12);

Flag Bedeutung

ios::skipws Überlese Whitespace

ios::scientific Wissenschaftliches Float-Format z.B. -1.23E+04

ios::fixed Festpunkformat für Float z.B. 123.45

Mit setw(int) lässt sich verhindern, daß Eingabepuffer überlaufen. Obiges Programm hätte die Strings besser so eingelesen:

 ...
 cin >> setw(puffergroesse); // lies hoechstens 
 while ( cin >> puffer) // puffergroesse Zeichen
 { ...

Weitere Eingabeoperationen

  Die Klasse istream stellt außer dem Operator >> noch andere nützliche Funktionen zur Verfügung, z. B.

    istream& get(char& c);
    istream& get(char* p, int n, char delim = '\n');
    istream& putback(char c);
    int get();
    int peek();

   

• get(Z) liest ein einzelnes Zeichen und speichert es in Z (auch Whitespace !).
• get(puffer, grenze, trennzeichen) liest eine Folge von höchstens grenze - 1 Zeichen und speichert sie in puffer. Wird das Ende der Datei erreicht oder das trennzeichen gelesen, werden weniger als grenze -1 Zeichen geliefert.
• putback(c) schickt das Zeichen c in den Eingabestrom zurück.
• get() liest ein Zeichen und liefert es als Ergebnis zurück (auch EOF).
• peek() liefert das nächste Zeichen ohne es einzulesen (auch EOF).

Benutzerdefinierte Extraktions-Operatoren >> lassen sich ebenfalls definieren.    

Die erforderliche Signatur ist

istream& operator >> (istream& IS, classtype& E)

Solche Eingabefunktionen sind in der Regel komplizierter als Ausgabefunktionen, da sie im Fehlerfall die Statusbits des Eingabestroms setzen müssen.

Ein/Ausgabe von Dateien

           

Öffnen eines Ausgabe-Files und Verbindung mit einer Datei:

   ofstream outp("outfilename");

Öffnen eines Eingabe-Files und Verbindung mit einer Datei:

   ifstream inp("infilename");

Öffnen eines Ein/Ausgabe-Files und Verbindung mit einer Datei:

   fstream iof("filename", mode);

Test, ob das Öffnen der Datei erfolgreich war:

    ifstream eingabe("inp");
    if (!eingabe)
    {    cerr << "Cannot open file inp\n");
         exit(1);
    }

Ein File-Objekt läßt sich auch erst kreieren und später öffnen:

    ifstream eingabe;    // Default-Konstruktor
    eingabe.open("inp"); // Oeffnen
    ...
    eingabe.close();     // Schliessen

Der I/O-Modus kann auch explizit angegeben werden, z. B.:

    ifstream inp("infile", ios::in);
    ofstream outp("outfile", ios::out);

Flag Bedeutung

ios::app Anhängen von Daten an Ausgabe-File

ios::out Ausgabe (mit Überschreiben)

ios::in Eingabe

ios::nocreate Öffnet nur Dateien, die existieren

ios::noreplace Öffnet nur Dateien, die nicht existieren, es sei denn zum Anhängen.

Neben den Operatoren << und >> können auch die Funktionen get() und put() benutzt werden.        

Beispiel: Filecopy-Programm  

#include <stdlib.h>   // fuer exit()
#include <fstream.h>

int main(int argc, char **argv)
{ if (argc < 3)
  { cerr << "Usage: filecopy inp outp\n"; exit(0);}
  ifstream inp(argv[1]);
  if (!inp)
  { cerr << "Cannot open " << argv[1]; exit(1);}
  ofstream outp(argv[2]);
  if (!outp)
  { cerr << "Cannot open " << argv[2]; exit(1);}

  char c;        // jetzt geht's los:
  while (inp.get(c) && outp) outp.put(c);
} /* main */

Ein/Ausgabe von und in Strings

       

• Internes Erzeugen von Ausgabetexten.
• Stringverarbeitung und Manipulation.

Zwei vordefinierte Klassen:

• ostrstream: Schreiben in Strings.
• istrstream: Lesen aus Strings.

Schreiben in Strings    

Beispiel:

   const int buflen = 128;
   char buf[buflen];
     
   char *greet(char *name)
   { // stream oeffnen und mit "buf" verbinden:
     ostrstream s(buf,buflen);
     s << "Hello " << name << "!\n";
     return buf;
   }
   int main(void)
   { cout << greet("Krause");
   } /* main */

Lesen aus Strings    

Beispiel:

   const int buflen = 128;
   char buf[buflen] = "120     Mueller   17.25";

   int main(void)
   { int num;
     char name[20];
     float dollar;
     istrstream s(buf,buflen);
     s >> num >> name >> dollar;
     cout << "Num: " << num 
          << " Name: " << name 
          << " Dollar: " << dollar << endl;
   } /* main */