ich bin noch recht neu bei C++ und möchte jetzt mein erstes größeres Projekt in Angriff nehmen. Dabei möchte ich Dateien einlesen und deren Inhalt interpretieren. Die Dateien sehen beispielsweise so aus:

www.cae.tntech.edu/~mwr/pbs-tests/fluent/pipe_sf.cas

Die Dateien sind teils sehr groß (~ 5GB) und enthalten binäre Zeichen. Ich denke grob an folgednes Vorgehen und wollte Euch mal um eure Meinung dazu fragen:

1. Datei am Stück in den Steicher laden - es ist genug RAM da und es soll schnell gehen.

2. Einen Zähler einführen den Level zu zählen: Level 0 - außerhalb einer Sektion, Level 1: eine öffnende Klammer, .... Die Blöcke der Files sind immer streng in Klammerblöcke eingeschlossen. Wie ich die Datei effektiv nach Klammerpaaren durchsuche ist mir noch unklar.

3. Zu Beginn eines Blocks entscheidet dann nach der öffnenden Klammer die zwei- oder vierstellige ASCII-Zahl, ob ich die Informationen im folgenden Block sichern muss oder nicht. Wenn ich nicht sichern muss, dann genügt es den Beginn des nächsten Blcoks zu suchen, andernfalls muss ich wohl eine geeignete Speicherstruktur aufbauen. Details dazu muss ich mir noch überlegen.

Was meint Ihr soweit dazu? Ich werde mal anfangen und dann immer wieder Schnipsel posten. Freue mich über jeden Anregung.

Grüße BastiL

Na, wenn das dein OS und deine Formatierung aushalten.

Dan musst da aber schon mal auf Überläufe von Variablen achten. Das kann bei solchen Grösse wahrscheinlich schnell zustande kommen..

Ein kleiner Tipp:
Wenn du noch wirklich anfänger bist, dann würde ich mich mal mit kleineren Sachen beschäftigen. In zwei verschiedenen Bedeutungen.
Erstens einfaches Dateihandling üben und am besten auch gleich ein wenig mit den Grenzen bekannt machen und zweitens keine 5GB Files am Anfang parsen wollen. machs mit einer, die sehr klein ist (vlt. so 100 Zeilen), dann geht das ganz fix und du kannst auch einfacher debuggen. Wenn die Tests dann mal durch sind, kannst du dein Programm mal auf die 5GB loslassen und gemütlich einen Kaffee trinken gehen.

Über die Komplexität der Files weiss ich jetzt nicht, aber da würde sich unter umständen auch ein paar Hilfsmittel eignen.
Boost::Spirit könnte sich da, wenn es komplexer wäre anbieten:
http://www.boost.org/doc/libs/1_37_0/libs/spirit/classic/index.html

Dann wünsche ich dir mal viel Spass.
5GB... tztztz..

5GB Files?! Und du willst das mal eben in den RAM laden?!

Na, wenn das dein OS und deine Formatierung aushalten.

Kein Problem. Wir haben das Equipment. Mit Python mache ich das schon regelmäßig.

drakon schrieb:

Ein kleiner Tipp:
Wenn du noch wirklich anfänger bist, dann würde ich mich mal mit kleineren Sachen beschäftigen. In zwei verschiedenen Bedeutungen.
Erstens einfaches Dateihandling üben und am besten auch gleich ein wenig mit den Grenzen bekannt machen und zweitens keine 5GB Files am Anfang parsen wollen. machs mit einer, die sehr klein ist (vlt. so 100 Zeilen), dann geht das ganz fix und du kannst auch einfacher debuggen. Wenn die Tests dann mal durch sind, kannst du dein Programm mal auf die 5GB loslassen und gemütlich einen Kaffee trinken gehen. ;

Das ist klar. Ich entwickle an viel kleineren Files. Das Beispiel das ich geschickt habe ist auch viel kleiner.

drakon schrieb:

Über die Komplexität der Files weiss ich jetzt nicht, aber da würde sich unter umständen auch ein paar Hilfsmittel eignen.
Boost::Spirit könnte sich da, wenn es komplexer wäre anbieten:
http://www.boost.org/doc/libs/1_37_0/libs/spirit/classic/index.html

Zu den Files siehe mein Link. Das Teil kenne ich aber ich habe es aussortiert weil das Handling von Binärdaten da wohl nicht so trivial ist. Es existiert für diese Dateien eine flex-Grammatik die an demselben Problem krankt - Binärdaten ist nicht.

drakon schrieb:

Dann wünsche ich dir mal viel Spass.
5GB... tztztz..

Danke.

Schau am besten auch mal hier vorbei:

http://www.cplusplus.com/reference/iostream/

Da findest du praktisch alles, was die Std-Lib von C++ zu bieten hat.
Dich dürfte da vor allem std::ifstream interessieren. Ein gutes Tutorial oder noch besser ein Buch würde ich aber auch empfehlen.

Eines von den beiden sollte für den Anfang reichen:

http://www.mindview.net/Books/TICPP/ThinkingInCPP2e.html

http://www.amazon.de/C-Primer-Stanley-B-Lippman/dp/382732274X

Die Datei besteht aus Blöcken die durch öffnende und schließende Klammerpaare begrenzt sind. Die erste Zahl nach dem Öffnen des Blocks gibt den Typ an und legt damit fest, ob ich den Block brauche oder nicht. Jetzt wäre es vielleicht sinnvoll, die Datei schon beim einlesen in Blöcke zu zerlegen und nur di eBlöcke zu behalten, die ich brauche, oder? Wie könnte ich das angehen?

Danke BastiL

Jetzt wäre es vielleicht sinnvoll, die Datei schon beim einlesen in Blöcke zu zerlegen und nur di eBlöcke zu behalten, die ich brauche, oder? Wie könnte ich das angehen?

Das hängt auch davon ab, wie du einliest. Wenn du mit std::fstream einliest und den Text in einem std::string (genauer gesagt in einem Container davon) speicherst, kannst du je nach Fall eben den Container um einen neuen Eintrag erweitern oder nicht.

Falls dir nicht klar ist, was Container sind, kannst du mal hier schauen.

und den Text in einem std::string (genauer gesagt in einem Container davon) speicherst, kannst du je nach Fall eben den Container um einen neuen Eintrag erweitern oder nicht.

Ok das werde ich mir ansehen, danke. Kann ich in dem Container auch binäre Daten speichern oder müssten die dann direkt beim Einlesen vor dem speichern interpretiert werden?

BastiL

std::ifstream infile("Text.txt", std::ios::binary);  
      std::ostringstream os;
    os << infile.rdbuf(); 
    std::string parse_str(os.str());

Habe ich so noch Zugriff auf die Binärdaten oder ist das "kaputt"?

Außerdem hat sich gezeit, dass meine Idee mit dem LEvel zählen schief geht - die BInärdaten verwirren den Zähler... Deshalb suche ich nach Alternativen. Es dürfe nicht ganz so einfach werden den Stream direkt beim Einlesen aufzuspalten. Daher brauche ich wohl reguläre Ausdrücke um hinterher die Header zu suchen, was meint ihr?

Danke.

Die Datei besteht aus Blöcken die durch öffnende und schließende Klammerpaare begrenzt sind. Die erste Zahl nach dem Öffnen des Blocks gibt den Typ an und legt damit fest, ob ich den Block brauche oder nicht. Jetzt wäre es vielleicht sinnvoll, die Datei schon beim einlesen in Blöcke zu zerlegen und nur di eBlöcke zu behalten, die ich brauche, oder?

Ich würde die Datei einfach von vorne nach hinten durchgehen und die Struktur aufbauen, dabei die unnützen Blöcke weglassen, klar. Dabei solltest du dir aber erst überlegen, wie du den Inhalt der Datei in deinem Programm repräsentieren willst. Auf den ersten Blick sieht's nach sowas aus:

struct Block
{
    enum Type
    {
        Bla = 0,
        Blubb = 4,
        Foo = 37,
        ...
    };

    std::string        content; // Oder was komplexeres/zusammengesetztes
    std::vector<Block> sub_blocks;
};

std::vector<Block> data;

Wenn du die Datenstruktur hast, kannst du dich an's Einlesen machen, vorher macht's imho keinen Sinn. Der Level-Zähler kann sinnvoll sein, muss aber nicht. Da die Blöcke anscheinend verschachtelt sind, wirst du wohl eh rekursiv parsen müssen, da ist der Level egal.
Mit boost::spirit oder Regex-Krams würde ich das Parsen nicht angehen, da braucht die 5GB-Datei wahrscheinlich 'ne Woche bis sie geladen ist, abgesehen von dem Binär-Krams dazwischen. Und so kompliziert scheint das Format nicht zu sein.

Für den Anfang: Rohe Bytes einzulesen geht etwa so:

std::ifstream infile("Text.txt", std::ios::binary);  
infile.seekg( 0, std::ios::end );
size_t filesize = infile.tellg();
infile.seekg( 0, std::ios::beg );

std::vector<char> buffer( filesize );
if ( filesize > 0 )
    infile.read( &buffer[0], filesize );

was Du mit rekursiv parsen meinst verstehe ich aber nicht. Außerdem ist es knifflig gleich beim Einlesen die Struktur aufzubauen weil das Ende der Blöcke schwer zu finden ist - ein einfaches Suchen nach ')' scheidet aus. Aber wahrscheinlich hast Du viel bessere Ideen als ich?

Das heisst du gehst "einfach" durch den Text und sobald du zu einem ( kommst, weisst du, dass jetzt ein Block folgt, also kannst du die Funktion, die dir einen Block liest nochmal aufrufen (rekursiv halt) bist irgendwann das erste ) kommt, dann geht es wieder zurück.

Das kannst du dir so vorstellen, wie, wenn du deine UrUrUr Grosseltern frägst, wie denn alle ihre abkömmlinge heissen. (Zuerst werden die Kinder aufgezählt, dann die Kinder der Kinder usw. ) Im Code sieht das dann etwa so aus:

kinder[] kind::gibKinder ( kind )
{
   kinder[] = NULL;

   foreach (kinder as k )
     kinder[] = k->gibKinder ();

   return kinder;
}

so etwas ähnliches habe ich mit meinem LEvel-Zähler versucht und es lief nicht, weil die Binärzeichen teils als öffnende oder schließende Klammern interpretiert werden.....

es lief nicht, weil die Binärzeichen teils als öffnende oder schließende Klammern interpretiert werden.....

Das Format wird ja irgendwie spezifizieren, wie der Binärstrom anfängt und endet. Den dann also gesondert parsen

Das Format wird ja irgendwie spezifizieren, wie der Binärstrom anfängt und endet. Den dann also gesondert parsen

Nicht wirklich. Das wird ebenfalls durch öffnende bzw. schließende Klammern gemacht. Allenfalls durch den jeweiligen Header.