Ich habe hier ein altes C Programm und möchte es unter C++ etwas aufmöbeln.
Ich lese eine Datei in eine Variable:

unsigned char *variable = (unsigned char*) malloc(filesize+1);
read(handle,&variable[0],filesize);

Programm bedingt, da der Inhalt Zahlenkolonen sind und immer exakt an der selben Stelle stehen, nutze ich dann:

int zahl = 0;
memcpy(&zahl,&vaiable[126],2); // 2Byte Integer

free (variable);

Mich würde nun interessieren was ein C++ Mensch daraus machen würde

char *variable = new char[filesize+1]; // unsigned unnötig da eh nur puffer
handle.read(variable, filesize); // c++-stream vorausgesetzt 

short zahl = *( reinterpret_cast<short*>(variable + 126) );

delete[] variable;

Der Cast ist Implementationsabhängig (short muss nicht immer 2 Byte haben).

Ungetestet, undurchdacht, demnach keine Garantie

aus malloc macht er new, aus free ein delete. Aber eigentlich nimmt er dafür ifstreams:

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

using namespace std;

int main() {
  ifstream ifs("datei.txt");

  if (!ifs)
    return 1;

  vector<string> v; 
  string s("");

  while (ifs.good()) {  
    getline(ifs, s);  //zeilenweise einlesen
    vec.push_back(s); //und in vektor ablegen
  }
  ifs.close();
  return 0;
}

MfG

GPC

short zahl = *( reinterpret_cast<short*>(variable + 126) );

Der Cast ist Implementationsabhängig (short muss nicht immer 2 Byte haben).

Der Dateisyntax kommt noch aus DOS Zeiten. Ein sehr altes Programm das ich jetzt auf Windows konvertieren möchte.

Die oben aufgezeigte Variante wäre darum nicht möglich, da das int zum Beispiel als auch 1Byte abgelegt sein kann. Die Dateistruktur ist auf "klein" ausgelegt und auf Speicher schondend. Obriges Beispiel würde also schon Bytes lesen die garnicht für den Wert bestimmt sind. Man muss schon exakt sagen können von welcher Stelle man wieviel Bytes lesen möchte.

Auch find ich die new/delete Methode nicht wirklich optimal. Normal möchte man doch das die Speicherverwaltung eventuelle Leaks selber killt.
Hier muss man wirklich drauf achten das das delete auch gemacht wird.

GPC schrieb:

Hallo,

aus malloc macht er new, aus free ein delete. Aber eigentlich nimmt er dafür ifstreams:

Hier wäre die Speicherverwaltung dank vector schon auf der "sicheren" Seite. Wie kann ich dort aber einem Zahlenwert wie oben übergeben?
Beispielsweise von Stelle 455 sind 3 Bytes der Integer Wert den ich benötige. Über ein Beispiel würde ich mich freuen

Auch find ich die new/delete Methode nicht wirklich optimal. Normal möchte man doch das die Speicherverwaltung eventuelle Leaks selber killt.
Hier muss man wirklich drauf achten das das delete auch gemacht wird.

Und bei malloc/free musst Du nicht auf das free achten?

Hier wäre die Speicherverwaltung dank vector schon auf der "sicheren" Seite. Wie kann ich dort aber einem Zahlenwert wie oben übergeben?
Beispielsweise von Stelle 455 sind 3 Bytes der Integer Wert den ich benötige. Über ein Beispiel würde ich mich freuen

In dem Fall kannst Du einen vector des kleinsten gemeinsamen Wertes (wenn ich das richtig verstanden habe 1 Byte also char) hernehmen und ansonsten im groben dasselbe wie in C machen. Es gibt auch in C++ keine Datenstruktur für "irgendwas"

BTW: Wenn überall auch kleinere Werte steghen können, woher weisst Du, an welcher Stelle was steht?

cianner schrieb:

Auch find ich die new/delete Methode nicht wirklich optimal. Normal möchte man doch das die Speicherverwaltung eventuelle Leaks selber killt.
Hier muss man wirklich drauf achten das das delete auch gemacht wird.

Und bei malloc/free musst Du nicht auf das free achten?

Ja eben, darum ist die Methode für C++ wohl nicht die optimale, genau darum sagte ich das ja auch.

LordJaxom schrieb:

Hier wäre die Speicherverwaltung dank vector schon auf der "sicheren" Seite. Wie kann ich dort aber einem Zahlenwert wie oben übergeben?
Beispielsweise von Stelle 455 sind 3 Bytes der Integer Wert den ich benötige. Über ein Beispiel würde ich mich freuen

In dem Fall kannst Du einen vector des kleinsten gemeinsamen Wertes (wenn ich das richtig verstanden habe 1 Byte also char) hernehmen und ansonsten im groben dasselbe wie in C machen. Es gibt auch in C++ keine Datenstruktur für "irgendwas"

BTW: Wenn überall auch kleinere Werte steghen können, woher weisst Du, an welcher Stelle was steht?

Die Positionen sind wie gesagt fest, darum gibts auch eine "Indextabelle".
Es gibt sogar Kombinationen wo über Bitverschiebung gearbeitet wird

Das ganze hat mir jetzt aber nicht wirklich weitergeholfen. Wie bekommt man aus dem vector jetzt von Position 455 einmal 3 oder 17 Bytes extrahiert und übergebe die einem float oder bei 17Bytes einem string?

Auch ein char ist ja nicht so optimal, da auch dort Index zum Einsatz kommen können und ein char buffer[2] mit strcpy(buffer,"123456"); auch niemand merkt das dies in die Hose geht. Ich hoffe ein paar Gurus wissen Rat

int main(int argc, char* argv[])
{
	int zahl = 0;

	// C++ VERSION
	ifstream ifs("test.dat");
	if (!ifs) return 1;

	vector<string> vec;
	string s("");

	while (ifs.good())
	{
		getline(ifs, s);  //zeilenweise einlesen
		vec.push_back(s); //und in vektor ablegen
	}
	ifs.close();

	memcpy(&zahl,&vec[100],2);
	printf("\nA: %d",zahl);

	// C VERSION
    int handle=open("test.dat",_O_RDONLY);
    if (!handle) return 1;

	long filesize=filelength(handle);
    unsigned char *oldstyle = (unsigned char*) malloc(filesize+1);
    read(handle,&oldstyle[0],filesize);
    close(handle);
	memcpy(&zahl,&oldstyle[100],2);
	printf("\nB: %d",zahl);
	free (oldstyle);

	getch ();
	return 0;
}

Ausgabe

A: 61453
B: 17490

Kann mir eventuell wer den Fehler sagen und wie man diesen berichtigt? Danke!

hab mir nicht alles angeschaut, aber ich lese immer bis zum dateiende ein (also eof), und nicht, bis ein fehler gesetzt wird!

Erstens setzt ein EoF auch das failbit und zweitens landest du in einer Endlosschleife, wenn du andere Streaming-Fehler nicht abfängst. Da ist es schon besser, den Gesamtstatus des Streams abzufragen.

@cianner: in der C++ Version fragst du die ersten Bytes von Zeile 100 der Datei ab, in der C-Version die Bytes 100 und 101. Nimm lieber einen vector<char> oder einen Einzelstring und lies per get() den Dateiinhalt ein.

vector<char> vec;
	char chr;

	while (ifs.good())
	{
		ifs.get(chr);
		vec.push_back(chr);
	}

danke für eure Hilfe, sollte ich doch noch auf Probleme stossen, werde ich wieder euren Rat suchen

ser1al schrieb:

hab mir nicht alles angeschaut, aber ich lese immer bis zum dateiende ein (also eof), und nicht, bis ein fehler gesetzt wird!

Erstens setzt ein EoF auch das failbit und zweitens landest du in einer Endlosschleife, wenn du andere Streaming-Fehler nicht abfängst. Da ist es schon besser, den Gesamtstatus des Streams abzufragen.

So ganz astrein ist meine Version ja auch noch nicht (vgl. http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=eof#Answ), aber man kann sie benutzen, ohne nassgeschwitzt vor dem Rechner zu sitzen

MfG

GPC

char *variable = new char[filesize+1]; // unsigned unnötig da eh nur puffer

Warum ist unsigned unnötig?
Wenn man variable[234]==0xAA prüfen will, stehst aber dumm da. Schliesslich liegen in den Dateien Binärdaten.