Das fertige Ergebnis sollte folgendermaßen aussehen (In Anlehnung an den rechts dargestellten Baum – die Nummerierung erfolgt von links nach rechts):

[Wurzel] + [Blatt 1, Ebene 1] + [Blatt 1, Ebene 2] + [Blatt 1, Ebene 3]
         |                    |                    ` [Blatt 2, Ebene 3]
         |                    ` [Blatt 2, Ebene 1] + [Blatt 3, Ebene 3]
         |                                         ` [Blatt 4, Ebene 3]
         `[Blatt 2, Ebene 1] + [Blatt 3, Ebene 2] + [Blatt 5, Ebene 3]
                             |                    ` [Blatt 2, Ebene 3]
                              ` [Blatt 2, Ebene 1] + [Blatt 3, Ebene 3]
                                                    ` [Blatt 4, Ebene 3]

Wir zeichnen also bei jeder Verzweigung ein Plus, dann den Namen des Blattes und immer so weiter, bis ein Blatt erreicht ist, dass sich nicht mehr verzweigt. Dann wird eine neue Zeile begonnen und so lange unter jedes Plus ein “|” geschrieben, bis man wieder auf dem Level angelangt ist, zu dem das Blatt gehört. Soweit so gut, ist ja nicht so komplex.

Die Probleme fingen bei mir an, als ich diese Idee in Code umsetzen musste: Ich hatte eine Liste mit Objektinstanzen, aus denen ein Baum generiert werden sollte.

Jedes Objekt hatte drei für die Ausgabe relevante Attribute:

Objekt* child1; //Der Pointer auf das erste Blatt dieser Objektinstanz
Objekt* child2; //Der Pointer auf das zweite Blatt dieser Objektinstanz
string name; // Der Name dieser Objektinstanz
//Die Pointer beziehen sich jeweils auf andere, in der Liste vorhandene Instanzen.

Also hatte ich folgende fixe Idee: Ich baue in das Objekt eine Funktion ein, die mir den String zusammenbastelt und sich, um die Verschachtelung darzustellen, wieder selbst aufruft. Damit muss ich nicht festhalten, welche Information von welchem Blatt nun ausgegeben werden soll. Fassen wir diese Idee in Pseudo-Pseudocode zusammen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# Die Funktion erhält eine Liste, in der jeder Index eine Zeile symbolisiert
# Zeile 1 also Index 0 usw...
def generate_tree (list_of_strings):
 # An die aktuelle Zeile den Namen unseres Blattes dranhängen
 list_of_strings.back().append( name )
 
# Wenn unser Objekt ein Kind hat, dann müssen wir ein 
# Plus dranhängen und die Rekursion anstoßen.
# Die Unterscheidung ob "+" oder "-" ist nicht notwendig, 
# sieht aber am Ende schicker aus:
 if has_child1:
  if has_child2:
   list_of_strings.back().append( "+" )
  else:
   list_of_strings.back().append("-")
 
  # Hiermit starten wir die Rekursion
  # Das Folgende soll einen Memberaufruf symbolisieren :)
  child1.generate_tree( list_of_strings )
 
 if has_child2: # Ein Objekt kann ja bis zu zwei Kinder haben
  buffer = "" #Einen Buffer anlegen
  # Die Position des letzten Plusses rausfinden
  p = list_of_strings.back().find_last_of( "+" ) 
  # Die Position des letzten Strichs rausfinden
  k = list_of_strings.back().find_last_of( "|" ) 
 
  if p < k: #Den höheren Wert der beiden müssen wir nehmen
   p = k
 
# Von 0 bis p in Einerschritten durchgehen
  for i=0 | i <= p | i++
   if i < p:
    if list_of_strings.back()[i] == "+" or list_of_strings.back()[i] == "|":
     buffer.append( "|")
    else:
     buffer.append( " " )
   else if i == p:
    buffer.append( "`" )
 
  list_of_strings.append( buffer )
 
  # Wieder eine Rekursion starten
  # Das ist auch ein Memberaufruf
  child2.generate_tree( list_of_strings )
# ENDE der Funktion

So…diese Zeilen verlangen ein wenig nach Erklärung:
Zeile 1: Wir hängen den Namen des Blattes an das letzte Element in der Liste dran. Es ist egal ob die aktuelle Instanz jetzt Wurzel ist oder nicht. Wichtig ist nur, dass die übergebene Liste nicht leer ist. Dafür muss beim Aufruf der Funktion beim Wurzelelement gesorgt sein.

Zeile 11-15: Hier wird nur unterschieden, ob die aktuelle Instanz ein oder zwei Blätter hat und dementsprechend das Verbindungszeichen gewählt

Zeile 19/20: Hier wird die Funktion generate_tree bei dem ersten Kind aufgerufen, mit Übergabe der auch von dieser Funktion verwendeten Liste. Dadurch ist gewährleistet, dass alle ersten Kinder des jeweils vorhergehenden Blatts in einer Zeile stehen.

Zeile 21: Nun ist die Funktion für das erste Kind durchgelaufen, wenn es ein zweites Kind gibt, wird es nun etwas schwieriger, einen String zusammenzubauen.

Zeile 22-26: Es wird ein Puffer angelegt (er wird am Ende die neue Zeile enthalten, die wir zusammengebaut haben), der Index des letzten Plusses und der Index des letzten senkrechten Striches herausgefunden. Zur Erinnerung: Striche sollten die Verzweigung über mehrere Zeilen hinweg kenntlich machen. Plusse sollten zeigen, dass dieses Blatt mehr als ein Kind hat.

Zeile 28-Ende: Die Zuweisung in Zeile 29 macht nur Sinn, wenn man sich die for-Schleife danach anschaut. Wir gehen jeden einzelnen Index der letzten Zeile in der Liste bis p durch. p ist der Index des letzten Plusses/letzten Striches, je nachdem welcher Index höher ist. Solange i < p gilt, wird unter jeden Strich/jedes Plus ein weiterer Strich gehängt (indem man dieses Zeichen an den Puffer hängt). Haben wir p erreicht, so wird ein “`” an den Puffer gehängt, weil jetzt endlich der Name des zweiten Kindes kommen kann.
Dazu hängen wir den Buffer an die Liste dran (er symbolisiert ja eine neue Zeile) und rufen generate_tree bei dem zweiten Kind auf, mit unserer Liste als Parameter.

—–

Eine Implementierung dieses Algorithmus in C++ könnte folgendermaßen aussehen: *klick*

Die Funktion funktioniert allerdings nur unter zwei Bedingungen:

• Verwendung eines Monospace-Fonts bei der Ausgabe
• Die übergebene Liste ist beim Aufruf der Funktion beim Wurzelelement NICHT leer. Sie muss mindestens einen leeren String enthalten.

Angenommen, wir haben eine ClientRequest-Nachricht, welche bestimmte Anfragen an den Server schicken kann. Beispielsweise die Anfrage, den Spieler im Spiel zu registrieren. Dies sieht in der .proto-Datei (gekürzt) folgendermaßen aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

message ClientRequest {
	enum Operation {
		REGISTER_PLAYER = 1;
		[...]
	}
	optional RegisterPlayerParameters register_player_parameters = 3;
	[...]
}
 
message RegisterPlayerParameters {
	required PlayerInfo player_info = 1;
	[...]
}
 
message PlayerInfo {
	required string name = 1;
	[...]
}

Dann sieht das C++-Snippet zum Versenden ungefähr so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

using namespace boost::asio;
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query(tcp::v4(), “127.0.0.1?, 12345); // host und port
tcp::resolver::iterator iterator = resolver.resolve(query);
 
sock = new tcp::socket(io_service);
sock->connect(*iterator);
 
// Hier die protobuf-messages
ClientRequest req; // diese wird wirklich angelegt
RegisterPlayerParameters* rpp; // pointer, da von req bereitgestellt!
PlayerInfo* info; // pointer, da von rpp bereitgestellt!
 
req.set_operation(ClientRequest::REGISTER_PLAYER); // Parameter für req setzen
 
// wir holen uns einen Pointer auf die RegisterPlayerParameter-Message !innerhalb! des ClientRequest-Objekts
rpp = req.mutable_register_player_parameters();
 
// wir holen uns einen Pointer auf die PlayerInfo-Message !innerhalb! des RegisterPlayerParameters-Objekts
info = rpp->mutable_player_info(); // mutable, damit wir es ändern können
 
// Mit diesem Pointer können wir die Attribute setzen
info->set_name(name);
 
boost::asio::streambuf b;
std::ostream os(&b); // Protobuf serialisiert in einen Stream (der im Endeffekt alles in einen Puffer schiebt)
 
// Das ClientRequest-Objekt “versandfertig” verpacken
req.SerializeToOstream(&os);
 
// Der ostream packt alles in den streampuffer b, den wir per asio versenden können
boost::asio::write(*sock, b);

Hätte ich einmal C++ RICHTIG gelernt und nicht alles zusammenklamüsert, wüsste ich sowas wahrscheinlich. Aber da der Grundkurs, den ich besucht habe, etwas arg verpeilt war und außer dem Klassenmodell und iostream kein C++ verwendete, sondern z.B. Speicher grundsätzlich mit “malloc” reservierte, war so etwas eben nicht drin.

Übrigens empfehlen die im “offiziellen” C++ Forum genau das, was ich auch im Hinterkopf hatte: geschachtelte Vektoren. Das wollte ich anfangs auch machen, dachte mir aber, dass es da doch was gescheites für geben müsste… mhja.

Das hier ist also mehr so für google, damit das andere auch finden ;D

http://www.cplusplus.com/forum/articles/7459/

Für alle, die an einem nicht so wirklich richtig funktionieren Paketmanager gescheitert sind, ist hier der Leitfaden:

1.  Qwt Libraries runterladen und entpacken in Verzeichnis X:

http://www.qwt.sourceforge.net

tar -xzf foo.tar.gz

2. Dann folgende Konsolenschritte:

cd ‘X‘ //Pfad in dem sich das extrahierte Qwt findet

qmake

sudo make

sudo make install

3. Damit sei es getan, könnte man meinen, doch ich musste die qwt-Libraries noch vermerken und zwar in /usr/local/lib/libc.conf

/usr/local/qwt-Name/lib

/*Name war in meinem Fall qwt-5.2.0*/

4. Und zum Schluss:

sudo ldconfig

Teilt mir bitte Fehler mit, ich habe die Methode bisher nur ein paar Mal verwendet.

Den Sourcecode und Windows-Binaries gibt es auf der  dazugehörigen Seite unten zum Download.

RndMp3Copy steht unter der CCGPL.

Dort werden auch die neuen Versionen erscheinen.