wchar_t fh[2];
fh[0] = 'c';
fh[1] = 'y';
file.write((wchar_t*) &fh[0], sizeof(wchar_t));
file.write((wchar_t*) &fh[1], sizeof(wchar_t));

unsigned long size = 64;
file.write((wchar_t*) &size, sizeof(long));

und wieder auslesen will:

wchar_t fh[2];
file.read((wchar_t*) &fh[0], sizeof(wchar_t));
file.read((wchar_t*) &fh[1], sizeof(wchar_t));

if(file.eof())
   std::wcout << "EOF";
// EOF tritt ein                                 //
// ist hier die Datei zu Ende? Warum             //
// Wenn ich char nehme, tritt das Prob nicht auf //

unsigned long size;
file.read((wchar_t*) &size, sizeof(long));

Würde mich seht über eine schnelle Antwort freuen.

Wenn ich mt den folgenden Zeilen in eine Datei schreibe:

[cpp]wchar_t fh[2];
fh[0] = 'c';
fh[1] = 'y';
file.write((wchar_t*) &fh[0], sizeof(wchar_t));
file.write((wchar_t*) &fh[1], sizeof(wchar_t));

Welchen Char-Type verwendet file? Und mit welchen Flags öffnest du file?

std::basic_fstream<wchar_t> file;
file.open(filename.c_str(), std::ios_base::out | std::ios_base::binary);

lesen:

std::basic_fstream<wchar_t> file;
file.open(filename.c_str(), std::ios_base::in | std::ios_base::binary);

Hat jemand schon eine Idee?

Wenn du einen wide-Stream verwendest, musst du die Anzahl der zu schreibenden Zeichen auch relativ zu sizeof(wchar_t) berechnen.
So sollte es gehen:

wchar_t fh[2];
fh[0] = 'c';
fh[1] = 'y';
file.write(&fh[0], 1);
file.write(&fh[1], 1);

unsigned long size = 64;
file.write((wchar_t*) &size, sizeof(long) / sizeof(wchar_t));

Lesen:

wchar_t fh[2];
file.read(&fh[0], 1);
file.read(&fh[1], 1);

unsigned long size;
file.read((wchar_t*) &size, sizeof(long) / sizeof(wchar_t));

vielen Dank.

bool encrypth(const std::basic_string<wchar_t>& str, const std::basic_string<wchar_t>& filename)
{
	std::basic_fstream<wchar_t> file;
	file.open(filename.c_str(), std::ios_base::out | std::ios_base::binary);
	if(!file)
		return false;

	wchar_t fh[2];
	fh[0] = 'c';
	fh[1] = 'y';
	file.write((wchar_t*) &fh[0], 1);
	file.write((wchar_t*) &fh[1], 1);

	unsigned long size = static_cast<unsigned long>(str.length() * 4);
	file.write((wchar_t*) &size, sizeof(unsigned long) / sizeof(wchar_t));

	unsigned long y;
	for(unsigned long i = 0; i < str.length(); i ++)
	{
		y = (str[i] + i) * (i + 10);
		file.write((wchar_t*) &y, sizeof(unsigned long) / sizeof(wchar_t));
	}

	return true;
}

bool decrypth(std::basic_string<wchar_t>& str, const std::basic_string<wchar_t>& filename)
{
	std::basic_fstream<wchar_t> file;
	file.open(filename.c_str(), std::ios_base::in | std::ios_base::binary);
	if(!file)
		return false;

	wchar_t fh[2];
	file.read((wchar_t*) &fh[0], 1);
	file.read((wchar_t*) &fh[1], 1);

	unsigned long size;
	file.read((wchar_t*) &size, sizeof(unsigned long) / sizeof(wchar_t));

	unsigned long y;
	for(unsigned long i = 0; i < size / 4; i ++)
	{
		std::wcout << L"EOF"; // tritt ab hier immer wieder auf...
		file.read((wchar_t*) &y, sizeof(unsigned long) / sizeof(wchar_t));
		std::wcout << y << L" ";
		str += static_cast<wchar_t>(y / (i + 10) - i);
	}

	return true;
}

fwstream Test(bla.bla , ios::in | ios::out)
wchar_t wide;
//so um ein wide character zu schreiben: 
Test << wide;
//so um einen zu lesen:
Test >> wide;

musst halt immer im auge behalten ob der Dateizeiger dort ist wo du ihn willst