Datei Binär lesen

Bei ifstream benutze die Memberfunktionen read und write...

MSS-Software

ja ok

habe ich jetzt so gemacht:

ifstream in("C:\\temp\\Neu1.pdf",ios::in | ios::binary);
	int length;
	char * buffer;
	//while (! in.eof() )
	//{
		in.seekg (0, ios::end);
		length = in.tellg();
		in.seekg (0, ios::beg);

		// allocate memory:
		buffer = new char [length];

		// read data as a block:
		in.read (buffer,length);	
	//};
	in.close();

sieht soweit schon ganz gut aus.

problem: im buffer steht nicht alles bis dateiende drin. hat das was mit der 256 zeichen begrenzung zu tun? weil eigentlich allokiere ich doch in einer größe der datei oder?

und wie stellst du fest das nicht alles drin steht? gibst du den buffer in der console aus?

CStoll

Nur um dich zu beruhigen: Im Buffer stehen mit Sicherheit alle Daten drin, die du eingelesen hast - nur bei der Ausgabe werden sie möglicherweise etwas gekürzt (\0 geht fast überall als Stringende-Zeichen durch, d.h. wenn du die Daten ausgeben willst, werden sie nur bis zum ersten Null-Byte geschrieben).

MSS-Software

ich kann das sehen indem ich die datei im hexedit öffne

gut, und wie kann ich dann über die \0 terminierung heraus weiter schreiben lassen?

ps: wenn ich aber debugge und mir den inhalt vom buffer anschaue, steht dort genau das gleiche drin wie später in der ausgabe

MSS-Software

!!! PROBLEMLÖSUNG !!!

sooooooooo, nach undendlich gescheiterten versuchen freue ich mich, die Lösung präsentieren zu dürfen.

vielleicht wäre das ja mal was für die FAQ beim normalen C++ weil ich ja so keine MFC

while (! in.eof() )
	{
		char c;
		c = in.get();       // get character from file
		str_Zeile.Format("%c",c);
		str_Daten += str_Zeile;
	};

	in.close();

so, jetzt ist es möglich dort eine 1:1 kopie von binären Dateien zu erstellen (\0 terminierung ist da auch kein problem mehr)

Bitte nicht in die FAQ übernehmen, der Code ist GROTTIG

MSS-Software

ok, dann mach mir einen vorschlag und sag mir nen code, wie es bitte anders funktioniert

ich denke du wirst den post hier komplett gelesen haben

also probier es bitte selber mit einer pdf aus und dann schick mit deine lösung

bin für jeden besseren vorschlag dankbar

hustbaer

Also ganz primitiv wäre das mal so zu machen (wenn du die ganze Datei in einen Puffer kopieren willst):

void read_file(char const* path, std::vector<char>& data)
{
	data.clear();
	std::ifstream is(path, std::ios::binary);

	for (;;)
	{
		std::ifstream::int_type ch = is.get();
		if (ch != std::ifstream::traits_type::eof())
			data.push_back(ch);
		else
			break;
	}
}

void write_file(char const* path, std::vector<char> const& data)
{
	std::ofstream os(path, std::ios::binary);
	os.write(&(data[0]), data.size());
	os.flush();
	if (!os.good())
		throw std::runtime_error("Write error.");
}

BTW: kann mir jemand verraten wie man bei einem basic_istream unterscheiden kann ob der Input "zu ende" ist, oder ein IO Fehler vorliegt? basic_istream::eof() liefert ja erst true zurück NACHDEM man schon versucht hat das letzte Zeichen zu lesen, und wenn man das versucht hat bekommt man sofort eofbit und failbit gesetzt.

Wäre dafür "badbit" vorgesehen? Wenn ja ist die Implementierung vom MSVC ziemlicher Müll, da die bei Verwendung von "get" das "badbit" NIE setzt - auch nicht wenn das Lesen auf Grund eines IO Fehlers fehlgeschlagen ist.

Ich finde es geht auch sehr gut mit der MFC:

CFile copy(_T("C:\\TESTCOPY.PDF"), CFile::modeCreate|CFile::modeWrite);
		CFile file(_T("C:\\TESTPDF.PDF"), CFile::modeRead);
		BYTE cbBuffer[512] = {0};
		UINT nBytes = 0;
		do {
				nBytes = file.Read(cbBuffer, 512);
				copy.Write(cbBuffer, nBytes);
		} while(nBytes >= 512);
		file.Close();
		copy.Close();

MFK

Es gibt, wie tvdog bereits beschrieben und verlinkt hat, fertige Funktionen zu diesem Zweck.

CStoll

@hustbaer: Am Dateiende sind eofbit und failbit gesetzt, bei einem "normalen" Einlesefehler nur das failbit (ist vor allem interessant, wenn du formatiert einliest - get() schluckt alles, was ankommt). badbit steht für katastrophale Fehler, bei denen der Stream praktisch zerstört ist.