Fehlerhafte Daten beim einlesen von einer exe Datei

styxer

Guten Abend!

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

So sollte deine Funktion aussehen:

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.

styxer

Super danke für die schnelle antwort. Kann ich an diesen vector am anfang noch meine FileSize anhängen, da ich die brauche. meine Funktion gehört nämlich zu einem netzwerk programm mit dem ich daten senden will und da muss ich die dateigröße mitsenden

std::vector<char> file_to_something(const char* path) {
  std::vector<char> data;
  data.push_back(irgendeinwert);
  std::ifstream file(path, std::ios::binary);
  data.insert(data.end(),
              std::istreambuf_iterator<char>(file),
              std::istreambuf_iterator<char>());
  return data;
}

Columbo

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; 
}

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.

styxer

Leider funktionieren beide Methoden nicht ganz so wie ich es mir vorstelle

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;
}

Arcoth schrieb:

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~?