Nun mal wieder zurück zu den optischen Ansprüchen von Code

Unter diesem etwas blumig geartetem, nichts-desto-trotz wichtigem(zumindest meiner Auffassung nach) Thema möchte ich die formalen Konventionen, die zur erfolgreichen Programmierung beitragen können diskutieren.

Mein eindeutiger Favorit bei Funktions- und Methodenbezeichnungen ist der Pascal-Case(camelCase + Großschreibung zu beginn). Mir ist dieser Programmierstil zuerst bei meinen ersten, rudimentären Programmierversuchen in VBA aufgefallen, wobei ich diesen dann dort assimiliert habe, und seitdem nicht mehr missen möchte. Wenn ich Code, der nich gemäß dieses Programierstiles geschrieben wurde lesen muss, fällt mir gleich ein gravierender Übersichtlichkeitsverlust auf, wobei ich jedes mal den Erfinder des Unterstrichs masakrieren könnte.
Eine weitere Problematik ist die Einrückung: Dort habe ich schon so viele schreckliche sachen gesehen, und diese GNU-Menschen - die machen das am schlimmsten. Wieso kann man nicht einfach eine neue Zeile beginnen, und auf der höhe des Keywords die Klammer öffnen, und dann erst einrücken?
Einfach mal als vergleich der Ästhetik und Übersichtlichkeit:

// Toll?
class Schuhgeschäft : public Folteranlage
{
public:
    void MüffelNachSchuhen(int duration)
    {
        // ...
    }
private:
    int schuhGröße;
};
// GNU (eig. C):
class schuh_geschäft : public folter_anlage
  {
public:
    void müffel_nach_schuhen (  int duration  )
      {
        // ...
      }
private:
    int var1__w_rem_by_pieter_van_der_koh; // Do we need that shit?
    // It seems free as in beer...
  };
// Andere leute(grr):
class schuh_geschäft : public folter_anlage {
public:
    void müffel_nach_schuhen(int duration) {
        // ...
    }
private:
    int _my_var_with_underscores_that_noone_really_need_and_only_take_up_space;
    int otofwa; // or_that_one_filled_with_acronyms
};

ich nehm die java jodeconvention

*codeconvention

mastercpp

Bei mir ist es normalerweise so:
Bezeichner werden immer klein geschreben. Makros werden immer komplett groß geschrieben. Bei mehrwortigen Bezeichnern helfen Unterstriche, wenn nötig. Klassen bekommen ein _t angehängt, wenn es nur eine Instanz gibt (die dann wie dir Klasse heißt ( class blub_t { /*...*/ } blub; )). Geschweifte Klammern kommen in eine neue Zeile. Normale und eckige Klammer werden ohne Leerzeichen davor oder dahinter geschrieben. Bei den Einrückungen halte ich mich an emacs.
Aber das ist alles Geschmackssache.

mastercpp schrieb:

...
Aber das ist alles Geschmackssache.

Jo

DEvent

egon2 schrieb:

mastercpp schrieb:

...
Aber das ist alles Geschmackssache.

Jo

Da jede vernueftige IDE einen Code-Formatierer hat, ist es egal.
Ich mag die Java-Konvetion.

class MeineKlasse
{
    private:
        int eineEigenschaft;
    public:
        MeineKlasse(int parameter) 
        {
            // code
        }

        void macheEtwas()
        {
            // code
        }
}

Frag mich eigentlich immer, an was die Leute immer sparen muessen, die alles in einer Zeile draengen.

Bashar

DEvent schrieb:

Frag mich eigentlich immer, an was die Leute immer sparen muessen, die alles in einer Zeile draengen.

Platz auf dem Bildschirm.

Wobei ich die Variablen ans untere Ende der Klasse verschieben würde, das gibt dann einen abgeschlossenen Block.