Binär aus/in Datei lesen/schreiben

Shade Of Mine

schau mal da

#include <stdio.h>

int main()
{
    FILE* fp = fopen("c:\\test.bin", "wb");
    char buf = 'A'; 
    char buf2[2] = { 0, 0};
    fwrite(&buf, 1, 1, fp);    // Schreibe Buchstabe A binär ("wb") in Datei
    fclose(fp);

    fp = fopen("c:\\test.bin", "rb");
    fread(buf2, 1, 1, fp);     // Lese 1 Zeichen binär ("rb") aus Datei in buf2
    fclose(fp);

    printf(buf2);              // Gebe Inhalt von buf2 mit printf() aus.
}

proggingmania

proggingmania

Nurve schrieb:

...
Also das Open-Book von www.galileocomputing.de sagt nicht viel.
...
Nurve

Das sagt nicht nur nicht viel, neeeeein, ich gehe da noch einen Schritt weiter und behaupte:

!!! Das sagt überhaupt nichts, rein gar nichts !!!
Du sollst ja auch drin lesen !

Kugge mal dada-> http://www.galileo-press.de/openbook/c_von_a_bis_z/c_018_004.htm

Da sind Tabellen:

Tabelle 18.3
Beschreibt die Zugriffsmöglichkeiten auf eine Datei (lesen,schreiben, etc.)

Tabelle 18.5
Öffnen im Text/Binärmodus.

Und dann gibt es da noch seitenweise Quellcode zum Ausprobieren !!

Gruß, p.

Mensch, ich weis doch wie ich eine Datei lesen und schreibe.
Ich weis nur keine Funktion, die es mir ermöglicht unformiert 16 oder 64 Bit zu lesen, dann zu manipulieren um sie dann wieder binär/unformatiert zu speichern.

Also: Die funktionen fopen, fclose, getc, putc .... kenn ich alle und hab sie auch alle schon ausprobiert. nur ermöglichen die mir eben nicht das, was ich machen möchte

mFg,
Nurve

c.rackwitz

fread, fwrite

das geht. finde raus wie.

Ok, vielen Dank. Auch wenn eine Beschreibung der Funktionen recht hilfreich gewesen wäre

mFg,
Nurve

c.rackwitz

willst mich wohl verarschen?
guck mal in dein galileo buch. da gibts ein ganzes kapitel zu fread.

was erwartest du? copy und paste des kapitels hier in den thread? kannste haben!

18.17.1 Blockweises Lesen – fread() downtop

Hier die Syntax der Funktion:
size_t fread(void *puffer, size_t blockgroesse,
             size_t blockzahl, FILE *datei);
size_t ist ein primitiver Systemdatentyp für die Größe von Speicherobjekten. fread() liest blockzahl-Speicherobjekte, von denen jedes die Größe von blockgroesse Bytes hat, aus dem Stream FILE *datei, der zuvor geöffnet wurde, in die Adresse von puffer. Für puffer muss dementsprechend viel Platz zur Verfügung stehen.

Abbildung
Hier klicken, um das Bild zu Vergrößern

Abbildung 18.6 Blockweises Lesen mit fread()

Es sei eine Datei namens »wert.dat« mit Inhalten von Integerwerten gegeben. Werden z.B. die ersten zehn Werte benötigt, sieht der Quellcode folgendermaßen aus:
/* fread.c */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
   int puffer[10];
   FILE *quelle;
   int i;
   quelle = fopen("wert.dat", "r+b");
   if(quelle != NULL)
      fread(&puffer, sizeof(int), 10, quelle);
   for(i = 0; i < 10; i++)
      printf("Wert %d = %d\n", i, puffer[i]);
 return EXIT_SUCCESS;
}
Folgende Zeile soll wie oben interpretiert werden:
fread(&puffer, sizeof(int), 10, quelle);
fread() liest 10 Datenobjekte mit der Größe von je sizeof(int) Bytes aus dem Stream quelle in die Adresse von puffer.

Ein wenig undurchsichtig dürfte der Parameter void *puffer bei fread() und fwrite() erscheinen. Mit dem void-Zeiger haben Sie den Vorteil, dass diesem Parameter ein Zeiger beliebigen Datentyps übergeben werden kann. In Kapitel 14, Zeiger, wurde dies bereits durchgenommen.

proggingmania

Nurve schrieb:

...

Gibt es Funktionen mit den man auch Binär 16Bit - 64Bit eine Datei
lesen und schreiben kann, wenn ja, welche?
Diese Funktionen müssen erstmal nicht portabel sein.
Hauptsache das ganze funktioniert (erstmal) unter Windows

Vielen Dank,
Nurve

Du kannst dir entsprechnende 16Bit-/ 64Bit-Puffer anlegen.
Diese Puffer kannst du dann in die Datei reinschreiben und auch wieder auslesen.

#include <stdio.h>

int main()
{

	FILE* fp = NULL; // Dateizeiger.
	// 64 Bit Puffer ( 8 Byte ).
	char BitBuf64[8] = { '0', '1', '2', '3', '4', '5', '6', '7' };
	char* file = "test.dat"; // Testdatei
	char errbuf[256] = "\n ****** Everything Oki Doki ****** \n";
	int i = 0;

	// Datei zum Schreiben öffnen.
	// "wb": w: write( schreiben )  b: binary ( binär )
	fp = fopen( file, "wb" );

	// Kontrolle, ob das Öffnen erfolgreich war.
	if ( !fp )
	{
		sprintf( errbuf, "Could not open %s :-( \n", file );
		perror( errbuf );
		return 1;
	}

	// 8 Byte in die Datei test.dat schreiben
	// und die Anzahl der geschriebenen Byte prüfen
	if ( sizeof(BitBuf64) != 
			fwrite( BitBuf64, sizeof(char), sizeof(BitBuf64), fp ) )
	{  // Ein Schreibfehler ist aufgetreten.
		sprintf( errbuf, "Failed on fwrite in file: %s :-( \n", file );
		perror( errbuf );

		if ( 0 != fclose ( fp ) )
		{ // Datei konnte nicht geschlossen werden.
			sprintf( errbuf, "Failed on fclose %s :-( \n", file );
			perror( errbuf );
		}
		return 1;
	}

	// Das Schreiben in die Datei war erfolgreich, Datei schliessen.
	if ( 0 != fclose ( fp ) )
	{ // Datei konnte nicht geschlossen werden.
		sprintf( errbuf, "Failed on fclose %s :-( \n", file );
		perror( errbuf );
		return 1;
	} // Datei schliessen

	// Datei zum Lesen öffnen.
	// "rb": r: read( lesen )       b: binary ( binär )	
	file = "I dont' exist dat";
	fp = fopen( file, "rb" );

	// Kontrolle, ob das Öffnen erfolgreich war.
	if ( !fp )
	{
		sprintf( errbuf, "Could not open %s :-( \n", file );
		perror( errbuf );
		return 1;
	}
	// 8 Byte aus der Datei test.dat einlesen und die eingelesene
	// Anzahl der Byte überprüfen.
	if ( sizeof(BitBuf64) != 
		fread( BitBuf64, sizeof(char), sizeof(BitBuf64), fp ))
	{
		sprintf( errbuf, "Failed on fwrite in file: %s :-( \n", file );
		perror( errbuf );

		if ( 0 != fclose ( fp ) )
		{ // Datei konnte nicht geschlossen werden.
			sprintf( errbuf, "Failed on fclose %s :-( \n", file );
			perror( errbuf );
		}
		return 1;
	}

	// Datei schliessen.
	if( 0 != fclose ( fp ) )
	{ // Datei konnte nicht geschlossen werden.
		sprintf( errbuf, "Failed on fclose %s :-( \n", file );
		perror( errbuf );
	}

	printf( "File: %s Content: ", file );
	// Anzeigen der Datei test.dat
	for ( i = 0; i < sizeof( BitBuf64 ); i++ )
	{
		printf(   "%c", BitBuf64[i]  );
	}

	puts(errbuf);

	return 0;  

}

Vielen Dank @all

mFg,
Nurve

PS: c.rackwitz, reg dich doch nicht gleich so auf. Mensch, ich habs übersehen (soetwas ist eben menschlich ).