Fehlerhafte Daten beim einlesen von einer exe Datei



  • 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.



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

  • Mod

    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.



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


Log in to reply