Vielen Dank und freundliche Grüße

char zeichen = 'a';
int zahl = 1234;
float f = 12.34f;
char text[] = {"hallo"};

diese Variablen hab ich mit zwei Funktionen einmal in eine Textdatei und in eine Binärdatei geschrieben.
Nun möchte ich jede einzelne Variable sowohl aus der Textdatei als auch aus der Binärdatei auslesen. Wichtig dabei ist, dass ich es Byteweise auslesen muss.

Vielen Dank für eure Antworten

int dec;
char dateiname[]="D:\\Eigene Dateien\\Text.bin";
FILE *datei;
if((datei=fopen(dateiname,"r"))==NULL)
cout << "Datei kann nicht geoefnett werden" << '\n';
else{
dec=fgetc(datei);
}

Hab folgende Variablen:

char zeichen = 'a';
int zahl = 1234;
float f = 12.34f;
char text[] = {"hallo"};

diese Variablen hab ich mit zwei Funktionen einmal in eine Textdatei und in eine Binärdatei geschrieben.

kannst Du uns die Funktionen zeigen?

bordon schrieb:

Nun möchte ich jede einzelne Variable sowohl aus der Textdatei als auch aus der Binärdatei auslesen. Wichtig dabei ist, dass ich es Byteweise auslesen muss.

Warum ist das wichtig? Wenn Du einen float byteweise liest, so ist es zunächst kein float mehr!

Lesen aus Textdatei geht so:

char zeichen;
    int zahl;
    float f;
    ifstream datei("eineDatei.txt"); // erfordert #include <fstream>
    if( datei >> zeichen >> zahl >> f ) {
       cout << "alles richtig geelsen" << endl;
       // usw.

cout << var1 << '\n';
cout << var2 << '\n';
cout << var3 << '\n';
cout << var4 << '\n';
}
}
[quote]

Diese Funktion klappt wie ich es haben will. Nun will unser Dozent, dass wir aus der Textdatei die Variablen Byteweise auslesen, um diese in Dezimaler-, Hexadezimaler-, Binärer Form anzeigen zu lassen.
Also muss die Ausgabe praktisch so ausehen:

Addr Dec Hex Bin ASC
0000: 97 61 01100001 'a'
0001: 13 0d 00001101 '.'
0002: 10 0a 00001010 '.'
0003: 49 31 00110001 '1'
0003: 50 32 00110010 '2'
usw....

Versteht ihr was ich meine!?

void fktTXT(char c[]){
    if(c[0]=='W' && c[1]=='T'){
       ofstream write("Text.txt");
       write << zeichen << endl;
       write << zahl << endl;
       write << f << endl; 
       write << text << endl;
    }
    else if(c[0]=='R' && c[1]=='T'){
       char var1[10]; int var2; float var3; char var4[50];
       ifstream read("Text.txt");
       read >> var1;
       read >> var2;
       read >> var3;
       read >> var4;
       
       cout << var1 << '\n';  
       cout << var2 << '\n';
       cout << var3 << '\n';
       cout << var4 << '\n'; 
    }
}

Diese Funktion klappt wie ich es haben will. Nun will unser Dozent, dass wir aus der Textdatei die Variablen Byteweise auslesen, um diese in Dezimaler-, Hexadezimaler-, Binärer Form anzeigen zu lassen.
Also muss die Ausgabe praktisch so ausehen:

Addr Dec Hex Bin ASC
0000: 97 61 01100001 'a'
0001: 13 0d 00001101 '.'
0002: 10 0a 00001010 '.'
0003: 49 31 00110001 '1'
0003: 50 32 00110010 '2'
usw....

Versteht ihr was ich meine!?

Du möchtest alos nicht(!) die Variablen auslesen, sondern die Bytes. Sag' das doch gleich. Das ist auch einfach

ifstream datei("Text.txt");
    datei >> noskipws; // liest auch Leerzeichen und LF
    int addr = 0;
    for( unsigned char byte; datei >> byte; ++addr ) {
        // 'addr' und 'byte' in dec, hex, bin und ggf. ascii ausgeben

Kannst du mir nun noch sagen, wie ich byte in dec, hex und bin anzeigen lasse??

Du möchtest das vollständige Programm! Was lernt Ihr denn bei Eurem Dozenten?

#include <iostream>
#include <fstream>
#include <locale> // ctype<>
#include <iomanip> // setw
#include <bitset>
#include <fstream>

int main()
{
    using namespace std;
    ifstream datei("Text.txt"); // ggf. datei( .., ios_base::binary );
    if( !datei.is_open() )
    {
        cerr << "Fehler beim Oeffnen der Datei" << endl;
        return -1;
    }
    datei >> noskipws; // alle Zeichen lesen
    cout << "Addr  Dec Hex Bin     Asc" << endl;
    //       0001: 255 ff 01011010 '.'
    const char fillc = cout.fill('0');
    const ctype< char >& ctype_ = use_facet< ctype< char > >( cout.getloc() );
    int adresse = 0;
    for( unsigned char byte; datei >> byte; ++adresse )
    {
        cout << setw(4) << adresse << ": " << setw(3) << int(byte) << " " << hex << setw(2) << int(byte) << dec
            << " " << bitset<8>( byte ) << " '";
        if( ctype_.is( ctype_base::print, char(byte) ) )
            cout << char(byte);
        else
            cout << '.';
        cout << "'" << endl;
    }
    cout.fill( fillc ); // Füllzeichen wieder zurücksetzen

    return 0;
}

Und nur so, er hat sogar zur Not seine Lösung zur Verfügung gestellt^^

#include <fstream>
#include <iostream>

using namespace std; // falls kein "using", muss "std::" vor "ofstream"

int main() {
float f=0.625, f1;
int i=-13, i1;
char ch;
//std::ofstream outFile;
ofstream outFile;
ifstream inFile;

//TextFile
outFile.open("C:\\scratch\\CPP.TXT");//Methode open in <fstream.h> nicht vorhanden
outFile << f << ' ' << i;
//myFile << endl; //Genau: Schreiben auf phys. Textdatei erfolgt mit endl
outFile.close(); //garantiert mit close

//BinFile
outFile.open("C:\\scratch\\CPP.BIN", ios::out | ios::binary); // OK
//outFile.open("C:\\scratch\\CPP.BIN"); // OK
outFile.write((char*)&f, sizeof(f));
outFile.write((char*)&i, sizeof(int));
outFile.close(); //Schreiben auf phys. Bin.Datei erst mit close

//TextFile: passende Variablen lesen
inFile.open("C:\\scratch\\CPP.TXT");
if(inFile.fail())
return 1; // exit falls Datei nicht existiert
inFile >> f1 >> i1; //eof erreicht! - siehe weiter
//inFile >> f1; // oder so
//inFile >> i1;
cout << "f1=" << f1 << endl;
cout << "i1=" << i1 << endl;
inFile.close();

//TextFile: einzelne Bytes lesen
inFile.open("C:\\scratch\\CPP.TXT");
//bei wiederholtem open kein automatischer Reset von eof(), good(), ...
inFile.clear(); //resetet eof(), good(), fail()
cout << endl << "Inhalt von CPP.TXT:" << endl;
while (!inFile.eof()) {
ch=inFile.get(); // 1 Zeichen lesen
cout << ch;
}
inFile.close();

//BinFile: passende Variablen lesen:
//inFile.open("C:\\scratch\\CPP.BIN", ios::in | ios::binary); // OK
inFile.open("C:\\scratch\\CPP.BIN"); // OK
inFile.clear(); //resetet eof(), good(), fail()
if(inFile.fail())
return 1; // exit falls Datei nicht existiert
inFile.clear();
inFile.read((char*)&f1, sizeof(f1));
inFile.read((char*)&i1, sizeof(int));
inFile.close();

//BinFile: einzelne Bytes lesen-also HexEditor simuleren
inFile.open("C:\\scratch\\CPP.BIN");
//bei wiederholtem open kein automatischer Reset von eof(), good(), ...
inFile.clear(); //resetet eof(), good(), fail(),...
cout << endl << endl << "Inhalt von CPP.BIN:" << endl;
while (!inFile.eof()) {
inFile.read((char*)&ch, sizeof(char));
cout << "0x" <<hex << (int)(ch & 0xff) << endl;
// hex ist Manipulator; konvertiert Ausgabe in Hex
// hex erwartet abwer eine int-Zahl (auch short,...)
// Um nur 1 Byte darzustellen (int hat 4 Bytes)
// wird der Bitoperator & eingesetzt
}
inFile.close();
return 0;

}

/*
//Loesung 1a: C++ classic
#include <fstream.h>

main ()
{
ofstream myFile1("C:\\scratch\\CPP.TXT");
// Öffnen (evtl. erst kreieren) der Datei
// "myFile.dat" zum Schreiben

//float f=0.625;
float f=0;

int i=-13;

// TextFile
//myFile1 << f << " " << i << endl;
myFile1.write((char*)&f,sizeof(f));
myFile1.close();
// Datei wieder schließen
// BinFile
ofstream myFile2("C:\\scratch\\CPP.BIN");
char buffer2[50];
int* pointer=(int*) buffer2;
pointer=-13;
myFile2.write(buffer2, 4);
//myFile2.write((char)&i, sizeof(int));
myFile2.close();

return 0;
}