Ich hab da ein kleines Problem und komm einfach nicht drauf warum es nicht funktioniert.

Hier mal mein Code:

char*	openfile(char* path)
{
	char				buffer[512]		=	"";
	char*				rbuf			=	"";
	std::fstream		data(path, std::ios::in | std::ios::binary);
	int					file_size		=	0;
	int					real_size		=	0;
	std::string			tmp				=	"";

	data.seekg(0L, std::ios::end);
	file_size		=	data.tellg();
	data.seekg(0L, std::ios::beg);

	tmp			=	std::to_string(file_size);
	real_size	=	((file_size + strlen(tmp.c_str())) + 1);
	tmp			=	std::to_string(real_size);
	tmp			+= "\n";

	while (!data.eof())
	{
		data.read(rbuf, 512);
		tmp += buffer;
	}

	rbuf = new char[real_size];
	strncpy_s(rbuf, real_size, tmp.c_str(), real_size);
	tmp = "";
	data.close();
	return rbuf;
}

mein Problem ist, dass die *.exe Datei zwar eingelesen wird, aber nicht richtig(also der Array wird immer mit falschen Zeichen befüllt). Liegt es vielleicht daran, dass ich einen CHAR als Dateityp verwende?

MfG,
styxer

std::vector<char> readfile(const char* path) {
  std::ifstream file(path, std::ios::binary);
  std::vector<char> data((std::istreambuf_iterator<char>(file)),
                          std::istreambuf_iterator<char>());
  return data;
}

Das entscheidende Problem an deinem Code ist "tmp += buffer": buffer muss nicht nullterminiert sein. String ist ausserdem nicht die beste Datenstruktur, binäre Daten zu speichern.

Generell eine inperformante Methode, auch wenn es hier möglicherweise keinen Unterschied macht.
Hier wird gezeigt wie es besser geht.

std::ifstream t(path, std::ios::binary); 
t.seekg(0, std::ios::end);
std::vector<char> buffer(t.tellg());
t.seekg(0);
t.read(&buffer[0], buffer.size());

Das ganze kann noch in ein Template ausgelagert werden.

ich poste hier mal meine 2 funktionen (open&save File) vielleicht ist es dann einfacher.

char*	openfile(char* path)
{
	char				buffer[512]		=	"";
	char*				rbuf			=	"";
	std::fstream		data(path, std::ios::in | std::ios::binary);
	int					file_size		=	0;
	int					real_size		=	0;
	int					x = 0, y = 0;
	std::string			tmp				=	"";

	data.seekg(0L, std::ios::end);
	file_size		=	data.tellg();
	data.seekg(0L, std::ios::beg);

	tmp			=	std::to_string(file_size);
	real_size	=	((file_size + strlen(tmp.c_str())) + 1);
	tmp.resize(real_size);
	tmp			=	std::to_string(real_size);
	tmp			+= "\n";

	rbuf = new char[real_size];

	while (!data.eof())
	{
		data.read(rbuf, real_size);
	}

	strncpy_s(rbuf, real_size, tmp.c_str(), real_size);
	tmp = "";
	data.close();
	return rbuf;

}
int		savefile(std::string data, char* path)
{
	int			size	=	0;

	int			x		=	0;
	int			y		=	0;

	char*		newdata =	"";
	std::string tmp		=	"";

	while (data[x] != '\n')
	{
		tmp += data[x];
		x++;
	}
	x++;
	while (data[x] != '\0')
	{
		data[y] = data[x];
		y++;
		x++;
	}
	data[y] = '\0';
	size = atoi(tmp.c_str());

	size = (size - strlen(tmp.c_str())) - 1;

	std::fstream FILE(path, std::ios::out | std::ios::binary);

	FILE.write(data.c_str(), size);

	FILE.close();
	return 0;
}

Generell eine inperformante Methode, auch wenn es hier möglicherweise keinen Unterschied macht.

Schätzungsweise 1% Performance-Unterschied ~wenn die Datei nicht im Cache liegt~?