C++-Programmierung: Programmierstil

Ein gewisser Programmierstil ist notwendig, um anderen Programmierern das Lesen des Sourcecodes nicht unnötig zu erschweren und um seinen eigenen Code auch nach langer Zeit noch zu verstehen.

Außerdem zwingt man sich durch einen gewissen Stil selbst zum sauberen Programmieren, was die Wartung des Codes vereinfacht.

Kommentare

Grundsätzlich sollten alle Stellen im Code, die nicht selbsterklärend sind, bestimmtes Vorwissen erfordern oder für andere Codestellen kritisch sind, kommentiert werden.

Eine gute Regel lautet: Kann man die Funktionalität mit Hilfe des Programmcodes klar formulieren so sollte man es auch tun, ansonsten muss es mit einem Kommentar erklärt werden. Im englischen lautet die Regel: "If you can say it with code, code it, else comment."

Goto-Anweisungen

Die goto-Anweisung ist unter Programmierern verpönt, weil sie ein Programm schlecht lesbar machen kann, denn sie kann den Programmlauf völlig zusammenhanglos an jede beliebige Stelle im Programm verzweigen und so sogenannten Spaghetti-Code entstehen lassen. Unter Umständen ist die goto-Anweisung hilfreich und vermeidet unnötig kompliziertes Aussteigen aus verschachtelten Gültigkeitsbereichen. Für weiter interessierte Leser sei auf setjmp/longjmp verwiesen. Dies sollte allerdings nur bedacht und an sinnvollen Stellen Anwendung finden. Da C++ eine objektorientierte und funktionale Sprache ist, gibt es meistens eine Alternative um eine goto-Anweisung oder unübersichtlichen Code zu vermeiden.

Als Stilfrage wichtig ist der sinnvolle Einsatz dieses Mittels und die Berücksichtigung von Gültigkeitsbereichen.

Beispiel A:

void f()
 {
    enum {a=80,b=50};
    int arBig[a][b];
    /* arBig wird gefüllt ... */
    /* arBig wird nach Wert 4 durchsucht */
    int w(0), x(0);

_mark1:  
    if (arBig[w][x] == 4) goto _gefunden;
    ++w;
    if (w = a) { w = 0; goto _mark2; }
    goto _mark1;
_mark2:
    ++x;
    goto _mark1;
_gefunden:
    throw std::exception("Hurra!");
 }

In Beispiel A erkennt man eine verwirrende und unsinnige Verwendung von goto

Beispiel B:

void f()
 {
    enum {a=80,b=50,c=70};
    int arBig[a][b][c];
    /* arBig wird gefüllt ... */
    /* arBig wird nach Wert 4 durchsucht */
    int w(0), x(0), y(0);
    for (;w<a;++w)
    {
       for (;x<b;++x)
       {
           for (;y<c;++y)
           {
                if (arBig[w][x][y] == 4) goto _suchende;
           }
       }
    }
//----- Suchende ------
_suchende:
    ;
 }

Das Beispiel B zeigt einen sinnvollen und sparsamen Einsatz von goto, an einer Stelle wo dieses Vorgehen wirklich einen Vorteil bringt. Hier müsste z.B. eine Verkettung von break mit Hilfsflags oder eine Ausnahme angewendet werden um aus der verschachtelten Schleife ohne goto herauszukommen. Es sollten aussagekräftige Namen für die Sprunganker gewählt werden.

Namensgebung für Variablen und Funktionen

Es gibt viele verschiedene Wege, die man bei der Namensgebung von Variablen, Konstanten, Funktionen u.s.w. beschreiten kann. Zu beachten ist jedenfalls, dass man, egal welches System man verwendet, konsequent bleibt. Z.B. Variablen immer klein schreiben und ihnen den Typ als Abkürzung voranstellen, Funktionen mit Großbuchstaben beginnen und zwei Wörter mit Großbuchstaben trennen oder den Unterstrich verwenden.

Bei der Sprache, die man für die Bezeichungen wählt, sei aber etwas angemerkt. Wenn man Open-Source programmieren will, so bietet es sich meist eher an, englische Bezeichnungen zu wählen, ist man aber in einem Team von deutschsprachigen Entwicklern, so würde sich dann wohl die Muttersprache als bessere Wahl herauskristallisieren. Aber auch hier gilt: Egal was man wählt, konsequent muss man nach der Entscheidung bleiben!

Es gibt viele Methoden, die in der Praxis häufig Anwendung finden - alle mit ihren Vor- und Nachteilen:

• Ungarische Notation: Datentyp dem eigentlichen Variablennamen voranstellen.
• PascalCase: Verwenden von Großbuchstaben im Wort, um mehrere Wörter zu verbinden; z.B. EineVariable
• camelCase: eine Abwandlung von PascalCase, bei der mit einem Kleinbuchstaben begonnen wird (eineVariable); findet in Java-Programmen Anwendung.

Hoch zu Inhaltsverzeichnis