Ich möchte eine Binärdatei öffnen und erhalte dabei nur kauderwelch.

nach dem FAQ zu den Datenströmen ist das einlesen sicherlich richtig aber das ausgeben auf dem Bildschirm ist nicht wie gewünscht.

fstream FileBin("Testdatei1.gdi", ios::in|ios::binary);
if (FileBin.is_open())
{
    // 1. Dateigröße bestimmen.
    FileBin.seekg(0, ios::end);
    unsigned long FileSize = streamoff(FileBin.tellg());
    FileBin.seekg(0, ios::beg);

    // 2. Puffer anlegen und Datei einlesen.
    char* pBuffer = new char[FileSize];
    FileBin.read(pBuffer, FileSize);

	for(int i = 0; i < FileSize; i++){
		cout << pBuffer[i];
	}

    // Nachher wieder aufräumen.
    delete [] pBuffer;
}

Ich möchte einen Dank an die Leute aussprechen die mich bisher mir Rat und Tat bei Seite standen.

Mittels

cout << hex << (int)pBuffer[i] << ' ';

kannst du dir die Hexwerte der Bytes anschauen (wie bei einem Hexeditor).

Im Übrigen kannst du bei Binärdateien nicht mittels seek/tellg die Dateilänge bestimmen!

PS. manuelles rumspielen mit new/delete ist sehr gefährlich. Benutz lieber einen Container oder Smartpointer.

eigentlich sollte der Inhalt ungefähr so aussehen:

- die erste Zahl ist eine Integer und
- dann durch leerzeichen getrennte float-Zahlen

hmm,

eigentlich sollte der Inhalt ungefähr so aussehen:

- die erste Zahl ist eine Integer und
- dann durch leerzeichen getrennte float-Zahlen

Das ist aber nicht wirklich binär (unter "Binärdatei" verstehen die meisten hier, wenn du deine Daten in dem Format speicherst, in dem sie im Rechner verwaltet werden)

http://home.arcor.de/reichert13/Test1.dat

Die Datei Test1.dat:
- enthält binär ausgegebene Zahlenwerte
- der erste ist ein Integer-Wert und gibt die Anzahl der nachfolgenden Floatwerte an

Mit dem Integer-Wert dimensioniere ich ein Float Array. Nun möchte ich die nachfolgenden Float-Zahlen in ein Float-Vektor lesen.

FILE *pfile;

	int size;

	if ( fopen_s( &pfile, "Test1.dat", "rb" ) != 0 )

		fprintf( stderr, "Trouble opening file\n" );

	else

	{

	if ( !feof(pfile) ) fscanf_s(pfile, "%d", &size);
	if ( !ferror(pfile) && size > 0 )
			{

		cout << size << endl;

		float* pArr = new float[size];

/* ---------- ab hier hapert es --------------------------------- 

    	for (unsigned int ix = 0; ix < size && !feof(pfile); ix++)
		{
			fscanf_s(pfile, "%d", &pArr[ix]);
			cout << pArr[ix] << endl;
		}

-------------------------------------------------------------------- */
	}
	fclose( pfile );
	}

Also wenn ich die Datei so öffne ist der erste Integerwert bei mir = 4198489.
Mit dem das Array dimensioniert wird. Mein Bauch verrät mir, der Wert könnte etwas zu groß sein. Oder?

Wie komme ich dann sinnvolerweise an die floatwerte?

Hast du dich mit dem Thema überhaupt näher befasst?

Verstehst du auch, was du da programmierst oder "kopierst" du nur code?

Ich werd später wenn ich Zeit hab das evtl. mal versuchen.

- wenn ich in festen Blöcken springe, laufe ich gefahr das ich 2 Float-Werte zusammen in einem Block habe

ich schau mal wie weit ich mit fread komme.

@XaTrIxX ich nehme es dir nicht böse. Deine Aussage bezieht sich sicherlich auf die for()-Schleife, auch zurecht. Aber dieses war nur ein Versuch.

std::ifstream file_stream("Test1.dat", std::ios::binary);
if (!file_stream) throw std::runtime_error("could not open file \"test1.dat\"");

Das ist ja schonmal ein Anfang. Jetzt mal versuchen die Ganzzahl auszulesen (Was um Himmelswillen ist ein "Integer-Wert" in dieser Satzkonstruktion? "Integer" = "Ganzzahl")! Ein Array kann aber natürlich nur eine positive Anzahl an Elementen haben. In der Annahme, dass der Macher der Datei einen hinreichenden Kenntnisstand hatte, lesen wir also einen unsignierte (ohne +/-) Ganzzahl ein.
Wie schon erwähnt, versuchen wir das ganze, von d.h. sollten wir auch gucken ob es geklappt hat!

unsigned int arr_size(0);
file_stream.read(reinterpret_cast<char*>(&arr_size), sizeof(unsigned int));
if (!file_stream) throw std::runtime_error("\"test1.dat\" is corrupted");

Jetzt sollen ganz viele Fließkommazahlen(float's) kommen. Also legen wir schonmal einen Array an oder nehmen einen Container-Typ des Standards, und reservieren genügend Speicher.

float* arr_data(new float[arr_size]);

oder

std::vector<float> arr_data(arr_size);

.

Ein leerer Array hilft nur wenig, also kommen jetzt die Daten. Wenn nun aber irgendwas mit den Daten in der Datei nicht stimmt, kann man zum einen hingehen, und sagen, dass die Datei beschädigt ist, oder hingehen und einen Standardwert nehmen.

for (unsigned int i(0); i < arr_size; ++i)
{
    file_stream.read(reinterpret_cast<char*>(&arr_data[i]), sizeof(float));
    if (!file_stream) std::runtime_error("\"test1.dat\" is corrupted");
}

for (unsigned int i(0); i < arr_size; ++i)
{
    file_stream.read(reinterpret_cast<char*>(&arr_data[i]), sizeof(float));
    if (!file_stream) { file_stream.clear(); arr_data[i] = 0.0f; }
}

.

Jetzt haben wir alle Daten und sind glücklich!
Wenn wir uns am Anfang nicht für den Standardcontainer entschieden haben, sondern lieber selbst per new[] einen Array erzeugt haben, müssen wir diesen am Ende nochmal freigeben.

delete [] arr_data;

.

Und das war es auch schon Hoffe, das du jetzt nicht nur kopiert (dann klappt der Code übrigens nicht!) sondern es auch verstehst!

Wenn ich die *.dat in einen Hexeditor lade, ist der erste Wert die 13. Daraus folgt das wenn man den Hex-Wert umrechnet die erste zahl eine Dezimal 19 sein müßte.

Könnte das stimmen?

Demzufolge hätte erstmal mein Float-Array eine größe von 19.

FILE *pfile;
	fpos_t pos;

	int size[1];
	float buffer[40];

	if ( fopen_s( &pfile, "Test1.dat", "rb" ) != 0 )

		fprintf( stderr, "Trouble opening file\n" );

	else

	{

			fread(size, sizeof( int ), 2, pfile );
			if ( fgetpos( pfile, &pos ) != 0 )
				printf( "fgetpos error" );

		float* pArr = new float[static_cast<int>(size[0])];
			cout << "\n\n-->> " << size[0] << endl;

			if ( fsetpos( pfile, &pos ) != 0 )
				printf( "fsetpos error" );
				fread( buffer, sizeof( float ), 19, pfile );

				fclose( pfile );

                 for(int i = 0; i < 19; i++)
                     cout << " " << pArr[i];

	}

Hmm, so sieht es momentan bei mir aus. Bin mir nicht sicher ob ich richtig bin.

Wenn ich die *.dat in einen Hexeditor lade, ist der erste Wert die 13. Daraus folgt das wenn man den Hex-Wert umrechnet die erste zahl eine Dezimal 19 sein müßte.

Könnte das stimmen?

Ein int hat typischerweise die Größe von 4 Byte - d.h. du müsstest die ersten 4 Byte zusammenfassen, um die Arraygröße vergleichen zu können.

PS: Warum verwendest du nicht den Lösungsansatz, den (D)Evil präsentiert hat?

Dank Devils Vorschlag habe ich einen guten Vergleich der Endresultate.

Mir ist aufgefallen das bei dem Vorschlag den ich kurz vor Devil gepostet habe die erste Float fehlt(die erste Float nach dem Integer ). Diese wird mir nicht ausgegeben? während sie bei der Variante von Devil schön da steht.

Woran kann das liegen? Springe ich mit dem zeiger vorbei?

fread(size, sizeof( int ), 2, pfile );

Naja, sowas:

int size[1];

ist nicht soo die feine Art.

unsigned int size;
// ...
fread(&size, sizeof(unsigned int), 1, pFile);

Dann

float* pArr = new float[static_cast<int>(size[0])];

. Hier ist der static_cast überflüssig, da du eh einen int zurück gebkommst. size[0] => int. Ein *size tut es in dem Fall aber auch. Wenn du aber direkt einfach size als unsigned int (NICHT als Array) anlegst, hast du da einfach size stehen.