Binary Filetransfer

#include <iostream> // std::cout, std::endl, std::cin
#include <fstream> // std::fstream
#include <string>  // std::cin >>
#include <conio.h> // getch()

using std::fstream;
using std::system;
using std::cout;

struct datenStruktur
{
    char name[100];     // 100 Bytes
    char Nachname[100]; // 100 Bytes
    long nummer;        //   4 bytes
};

datenStruktur StrukturGruppe[] = {
    { "Meister", "Meier", 1 },
    { "Proper", "Nachname", 2 },
    { "MEISTERT", "Schroeder", 3 },
    { "Martin", "Krause", 4 },
    { "Marius", "Schmitz", 5 },
    { "frischer", "Hofmann", 6 },
    { "TonyStark", "Montana", 7 }
}, rDatenStruktur;


int main(void)
{
    // Binärdatei zum Schreiben und Lesen öffnen
    fstream stream("StrukturGruppeArray.dat", std::ios::in | std::ios::out | std::ios::binary);
    if (stream.is_open())
    {
        // Vorzeichenlose Int Variable mit dem Wert  ((204*7)/204) == 7! Errechnet die Anzahl
        // an datenStruktur im Array StrukturGruppe[]
        unsigned int uIStrukturArrayCount = (sizeof(StrukturGruppe) / sizeof(datenStruktur));
        // StrukturGruppenArray per Binäroperator übergeben
        // sowie die Gesamtgröße der StrukturGruppe in Bytes übergeben
        stream.write(
            (char*)&StrukturGruppe,
            uIStrukturArrayCount * sizeof(datenStruktur)
            );
        // Die gesamte Datenstruktur sollte jetzt auf deiner Platte neben deiner *.exe Datei
        // in "StrukturGruppeArray.dat" als Binärdatei gespeichert sein.
        // Falls das nicht geklappt hat, erstelle die Datei manuell!

        // Auf Nutzereingabe warten, welche bestimmt welche von denn Verfügbaren Datenstrukturen
        // gezielt aus der StrukturGruppeArray.dat geladen werden soll
        unsigned int datenSatz;
        do
        {
            cout << "Datensatz anzeigem: [1-" << uIStrukturArrayCount << "]: ";
            std::cin >> datenSatz;
        } while (datenSatz < 1 || datenSatz > uIStrukturArrayCount);
        /*
        *  Per fstream.write() haben wir eben das StrukturGruppe[] Array/Objekt binär nach StrukturGruppeArray.dat
        *  kopiert. Die Gesamt Göße der StrukturGruppeArray.dat Datei müsste exakt 1428 Bytes betragen.
        *  Mit fstream.read(...) kann der Inhalt der Datei wieder geladen werden. Bei einem einfachem Aufruf würde der
        *  Dateizeiger am Anfang der Datei (Position 0 inerhalb der Datei) anfangen und sie bis zum Ende auslesen.
        *  Mit der Methode fstream.seekg() können wir die Startposition ändern.
        *  Angenommen du gibst 5 bei "Datensatz anzeigem" ein, sähe die Berechnung für denn Aufruf so aus:
        *
        *       stream.seekg((5-1) * 204);
        *
        *  Minus 1 wird gerecchnet, weil die niedrigste Eingabe bei "Datensatz anzeigem" als 1 angezeigt wurde. sie
        *  aber in Wirklichkeit 0 ist. Die neue Rechnug sieht also so aus:
        *
        *       stream.seekg(816);
        */
        stream.seekg((datenSatz - 1) * sizeof(datenStruktur));
        // Als nächstes wird fstream.read() ausgeführt.
        stream.read(
            (char*)&rDatenStruktur,
            sizeof(datenStruktur)
            );
        /*
        *  Dem ersten Parameter wurde dem binärem Operator (char*) eine Referenz von rDatenStruktur übergeben.
        *  Der zweite Parameter besagt, wieviele Bytes ausgelesen werden sollen. Hier wurden umgerechnet 204
        *  übergeben was exakt eine Strukturgröße ist. Der Dateizeiger fängt also bei Byte 816 erst an und
        *  liesst auch nur 204 Bytes bis zum 1020ten Byte. Die Strucktur wird durch die Referenz übertragen.
        *
        */
        stream.close();
        cout << "Name: " << rDatenStruktur.name << "\t\t" \
            << "Nachname: " << rDatenStruktur.Nachname << "\t";
        cout << "Nummer: " << rDatenStruktur.nummer << std::endl;
    }
    else
    {
        stream.clear();
        cout << "StrukturGruppeArray.dat konnte nicht geladen werden!" << std::endl;
    }

    getch();
    return EXIT_SUCCESS;
}