#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h>   // EXIT_SUCCESS
#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;
}