Ich bin noch ziemlicher Anfänger in C++ und hab einige Fragen zu einer Klasse, die ich implementiert habe, um Dateien byteweise zu schreiben und auszulesen. Ich bedanke mich nochmal bei denen, die mir schon in anderen Threads bei einzelnen Sachen behilflich waren.

Ich würde es nett finden, wenn das mal jemand überfliegen könnte.

#include <fstream>
#include <string>
using namespace std;

class CFilestream {
public:
	CFilestream(wchar_t *filename, char type);
	~CFilestream();

	void write(short value);
	void write(int value);
	void write(float value);
	void write(char *value);

	short readShort();
	int readInt();
	float readFloat();
	string readString();
	// char *readString();

	void closeFile();
private:
	ifstream ifile;
	ofstream ofile;

	char type;
};

CFilestream::CFilestream(wchar_t *filename, char t) {

	type = t;

	if (type == 'r') {
		ifile.open(filename, ios::binary);
		ifile >> std::noskipws;
	} else if (type == 'w')
		ofile.open(filename, ios::binary);
	else
		ifile.open(filename, ios::binary);

}

void CFilestream::closeFile() {

	if (type == 'r')
		ifile.close();
	else if (type == 'w')
		ofile.close();
	else
		ifile.close();

}

void CFilestream::write(short value) {

	short a[2];

	a[1] = value & 0xFF;
	a[0] = value>>8 & 0xFF;

	ofile << unsigned char(a[0]) << unsigned char(a[1]);

}

void CFilestream::write(int value) {

	short a[4];

	a[3] = value & 0xFF;
	a[2] = value>>8 & 0xFF;
	a[1] = value>>16 & 0xFF;
	a[0] = value>>24 & 0xFF;

	ofile << unsigned char(a[0]) << unsigned char(a[1]) << unsigned char(a[2]) << unsigned char(a[3]);

}

void CFilestream::write(char *value) {

	short len = strlen(value);
	write(len);
	unsigned char c;

	for (short i = 0; i < len; i++) {
		c = value[i];
		ofile << c;
	}

}

int CFilestream::readInt() {

	unsigned char c1,c2,c3,c4;

	ifile >> c1 >> c2 >> c3 >> c4;

	return c1*256*256*256 + c2*256*256 + c3*256 + c4;

}

short CFilestream::readShort() {

	unsigned char c1,c2;

	ifile >> c1 >> c2;

	return c1*256 + c2;

}

// char *CFilestream::readString() {
string CFilestream::readString() {

	string value="";
	//char *value;
	value="";

	unsigned char c;
	short len = readShort();

	for (short i = 0; i < len+2; i++) {
		ifile >> c;
		value += c;
	}

	return value;

}

Nun meine Fragen dazu:

1. Was haltet ihr Allgemein vom Codestil? Ist das OK so oder sollte ich mir in C++ einen anderen Stil angewöhnen?

2. Wie man sieht, ist die Methode write() überladen, um short's, int's und strings in die Datei zu schreiben. Bei short's und int's werden die Variablen in ihre Bytes zerlegt und als char's in das file geschrieben. Schreibt man einen String in die Datei, wird zuerst dessen Länge geschrieben und dann die einzelnen Zeichen.
write(float value) würde ich auch noch gerne implementieren. Aber bevor ich das angehen wollte, kam mir der Einfall, dass die Variablentypen ja nicht auf jeder Architektur die gleiche Größe haben. Ich könnte natürlich mit sizeof() die Größen bestimmen. Aber wenn ich die Dateien auf einer anderen Architektur wieder auslesen möchte, weiß ich ja nicht, wie lang ein int/short/float in der Datei ist.

3. Ich weiß noch nicht, wie ich es anstellen soll, aus einzelnen Bytes einen float-Wert zu rekonstruieren. Ich könnte mir denken, dass das ganz einfach geht. Bloß ich weiß leider nicht, wie.

4. Die Methode readString() gibt den Typ string zurück. Dies möchte ich jedoch vermeiden. Da wäre mir der Typ char* am liebsten.

So, das wars erstmal von meiner Seite. Ich wäre euch sehr dankbar, wenn ihr euch das mal kurz anschauen könntet.

Grüße

Ich würde auch keine extra Klasse dafür schreiben. Wozu? Du kannst Dir noch diverse Ein/Ausgabe-Funktionen basteln, die ein ostream bzw istream per Referenz entgegennehmen und die Binärdaten per read/write lesen bzw schreiben.

Warum Du immer short-Arrays anlegst und dann doch zu unsigned char castest ist mir ein Rätsel.

Das blöde ist allerdings, dass read/write char* entgegennimmt und man aber besser unsigned char für's Umrechnen benutzt. Da weiß ich auch nicht, wie man das am besten löst.

Achte auch darauf, dass die Wertebereiche der Typen nicht standardisiert wurden. Die Details sind Implementierungs-spezifisch. Siehe int types.

Gruß,
SP