Bevorzugt ihr lieber die öffentlichen Schnittstellen an die erster Stelle zu schreiben damit die sofort sichtbar sind, oder schreibt ihr zuerst die privaten Elemente hin?

Variante A

class Klasse
{
private:
    int wert;

public:
    void wert(int);
    int wert();
};

Variante B

class Klasse
{
public:
    void wert(int);
    int wert();

private:
    int wert;
};

Welche Variante bevorzugt ihr?

Variante 1:
Von einem fremden Leser erwarte ich ohnehin, dass er in die Anleitung und nicht in den Header schaut. Der Deklaration ist in erster Linie für mich zum schnellen Nachgucken und Ändern da. Und da sind die private-Sachen viel relevanter, da sich die öffentliche Schnittstelle, wenn überhaupt, nur selten ändert.

Dem schließe ich mich an.

Ich sehe es wie ipsec.

Dito.

Ich würde mir gerne Variante 2 angewöhnen da es einen zusätzlichen Nutzen bringt, nur hätte ich dazu eine Frage. Kommt Doxygen oder wenn ich später mit GUI arbeite die Qt-Doku damit klar dass ich zuerst die öffentliche Schnittstellen deklariere?

DoxyGen hat keine Probleme.
Ich würde mich sehr wundern wenn QtDoc welche hätte.

Wenn ich den Standardkonstruktor als private deklariere dann mach ich den 'private' block zuerst - damit man das sofort sieht.

Ansonsten nehm ich die public Sachen nach oben.

Wenn ich den Standardkonstruktor als private deklariere dann mach ich den 'private' block zuerst - damit man das sofort sieht.

Es zwingt dich übrigens keiner, alles in einem Block zu machen. Du kannst auch deinen privaten Konstruktor nach oben machen und trotzdem den ganzen anderen private-Kram nach unten.

Es zwingt dich übrigens keiner, alles in einem Block zu machen. Du kannst auch deinen privaten Konstruktor nach oben machen und trotzdem den ganzen anderen private-Kram nach unten.

Stimmt. Man kann natürlich etliche public und private Blöcke machen. Aber das erwartet keiner (kommt Doxygen mit multiplen Blöcken klar?)

Wenn ich ne lange header-datei lesen muss*, weil ich nach den Zugriffsmethoden suche, dann schau ich an den Anfang. Wenn dort der public Block nicht ist, dann schau ich ans Ende. Wenn der public Block irgendwo im Zwischenraum versteckt wär' fänd' ich das irritierend.

*was ja eigentlich nicht so sein sollte, denn bei ner Headerdatei die über viele Seiten geht ist mit hoher Wahrscheinlichkeit irgendwas im Design faul - aber bei der Software die ich gerade vom Kunden bekommen hab' ist das zum Beispiel so. Insofern:

Von einem fremden Leser erwarte ich ohnehin, dass er in die Anleitung und nicht in den Header schaut.

ist sicher der Idealfall - aber gut dokumentierter Code (oder überhaupt extern dokumentierter Code) ist in meiner Erfahrung eher die Ausnahme als die Regel

class TheClass
{
  //----------------------------------------------------------------------------//
  // Attributes                                                                 //
  //----------------------------------------------------------------------------//

private:

  //----------------------------------------------------------------------------//
  // Constructors & Destructor                                                  //
  //----------------------------------------------------------------------------//

public:

private:

  //----------------------------------------------------------------------------//
  // Operators                                                                  //
  //----------------------------------------------------------------------------//

private:

public:

  //----------------------------------------------------------------------------//
  // Methods                                                                    //
  //----------------------------------------------------------------------------//

private:

public:
};

In dieser Reihenfolge erscheint in den Funktionen/Konstruktoren/Operatoren alles benötigte im allgemeinen zuerst. Ich verwende auch die gleiche Reihenfolge im *.cpp File. Wenn jemand meine Files lesen möchte, dann aus dem Grund, dass er die Implementation verstehen will. Für das andere ist schliesslich die Dokumentation vorhanden. Und wenn jemand den Sourcecode lesen möchte, dann ist es angenehm, wenn er von oben nach unten lesen kann und nicht immer hoch- und runterscrollen muss.

@antialias,
Doxygen hat überhaupt gar keine Probleme mit mehreren Sichtbarkeitsblöcken.

Grüssli