Wie soll ich die Mitglieder einer C ++ - Klasse bestellen?

Ist es besser, alle privaten Mitglieder zu haben, als alle geschützten, dann alle öffentlichen? Oder umgekehrt? Oder sollte es mehrere private, geschützte und öffentliche Labels geben, damit die Vorgänge von den Konstruktoren getrennt werden können und so weiter? Welche Punkte sollte ich bei dieser Entscheidung berücksichtigen?

Ich habe die öffentliche Schnittstelle an die erste Stelle gesetzt, aber das habe ich nicht immer getan. Ich habe Dinge rückwärts gemacht, mit privat, dann geschützt, dann öffentlich. Rückblickend ergab das wenig Sinn.

Als Entwickler einer Klasse kennen Sie wahrscheinlich die "Innereien", aber die Benutzer der Klasse kümmern sich nicht viel darum oder sollten es zumindest nicht. Sie interessieren sich hauptsächlich dafür, was die Klasse für sie tun kann, oder?

Also stelle ich die Öffentlichkeit an die erste Stelle und organisiere sie normalerweise nach Funktion / Dienstprogramm. Ich möchte nicht, dass sie durch meine Benutzeroberfläche waten müssen, um alle Methoden in Bezug auf X zu finden. Ich möchte, dass sie all diese Dinge auf organisierte Weise zusammen sehen.

Ich benutze niemals mehrere öffentliche / geschützte / private Bereiche - zu verwirrend, um meiner Meinung nach zu folgen.

Google bevorzugt diese Reihenfolge : "Typedefs und Enums, Konstanten, Konstruktoren, Destruktor, Methoden, einschließlich statischer Methoden, Datenelemente, einschließlich statischer Datenelemente."

Matthew Wilson (Safari-Abonnement erforderlich) empfiehlt die folgende Reihenfolge: "Konstruktion, Betrieb, Attribute, Iteration, Status, Implementierung, Mitglieder und mein Favorit, Nicht implementiert werden."

Sie bieten gute Gründe, und diese Art von Ansatz scheint ziemlich normal zu sein, aber was auch immer Sie tun, seien Sie konsequent.

Es ist meine Meinung und ich würde wetten, dass die meisten Leute zustimmen würden, dass öffentliche Methoden an erster Stelle stehen sollten. Eines der Grundprinzipien von OO ist, dass Sie sich nicht um die Implementierung kümmern müssen. Ein Blick auf die öffentlichen Methoden sollte Ihnen alles sagen, was Sie wissen müssen, um die Klasse zu verwenden.

Der Codierungsstil ist eine Quelle für überraschend hitzige Gespräche. Vor diesem Hintergrund riskiere ich eine andere Meinung:

Code sollte so geschrieben werden, dass er für Menschen am besten lesbar ist. Ich stimme dieser Aussage, die hier mehrmals abgegeben wurde, voll und ganz zu.

Die Abweichung ist, um welche Rolle es sich handelt.

Um dem Benutzer der Klasse zu helfen, die Verwendung zu verstehen, sollte eine ordnungsgemäße Dokumentation geschrieben und gepflegt werden . Ein Benutzer sollte niemals den Quellcode lesen müssen, um die Klasse verwenden zu können. Wenn dies erfolgt (entweder manuell oder mithilfe von In-Source-Dokumentationstools), spielt die Reihenfolge, in der öffentliche und private Klassenmitglieder in der Quelle definiert sind, für den Benutzer keine Rolle.

Für jemanden, der den Code verstehen muss , während der Codeüberprüfung, der Pull-Anforderung oder der Wartung, ist die Reihenfolge jedoch sehr wichtig - die Regel ist einfach:

Elemente sollten definiert werden, bevor sie verwendet werden

Dies ist weder eine Compiler-Regel noch eine streng öffentliche oder private Regel, sondern eine Regel des gesunden Menschenverstandes - der menschlichen Lesbarkeit. Wir lesen Code nacheinander und wenn wir jedes Mal, wenn wir ein Klassenmitglied sehen, "jonglieren" müssen, aber beispielsweise seinen Typ nicht kennen, wirkt sich dies nachteilig auf die Lesbarkeit des Codes aus.

Eine strikte Trennung zwischen privat und öffentlich verstößt gegen diese Regel, da private Klassenmitglieder angezeigt werden, nachdem sie in einer öffentlichen Methode verwendet wurden.

Wie immer schreiben Sie zuerst Ihren Code für Menschen . Betrachten Sie die Person, die Ihre Klasse verwenden und legen Sie die wichtigsten Mitglieder / Aufzählungen / typedefs / was auch immer , um sie an der Spitze.

Normalerweise bedeutet dies, dass öffentliche Mitglieder an der Spitze stehen, da dies die meisten Verbraucher Ihrer Klasse am meisten interessiert. Geschützt folgt, gefolgt von Privaten. Meistens.

Es gibt einige Ausnahmen.

Gelegentlich ist die Initialisierungsreihenfolge wichtig und manchmal muss eine private vor einer öffentlichen deklariert werden. Manchmal ist es wichtiger, dass eine Klasse geerbt und erweitert wird. In diesem Fall können die geschützten Mitglieder höher platziert werden. Und wenn Unit-Tests auf Legacy-Code gehackt werden, ist es manchmal einfacher, öffentliche Methoden verfügbar zu machen. Wenn ich diese Beinahe-Sünde begehen muss, platziere ich diese am Ende der Klassendefinition.

Aber es sind relativ seltene Situationen.

Ich finde, dass "öffentlich, geschützt, privat" für Verbraucher Ihrer Klasse meistens am nützlichsten ist. Es ist eine anständige Grundregel, sich daran zu halten.

Es geht jedoch weniger um die Bestellung per Zugang als vielmehr um die Bestellung nach Interesse des Verbrauchers .

Normalerweise definiere ich zuerst die Schnittstelle (zu lesen), die öffentlich, dann geschützt und dann privat ist. In vielen Fällen gehe ich jetzt einen Schritt vorwärts und verwende (wenn ich damit umgehen kann) das PIMPL-Muster, um alle privaten Dinge vollständig vor der Schnittstelle der realen Klasse zu verbergen.

class Example1 {
public:
   void publicOperation();
private:
   void privateOperation1_();
   void privateOperation2_();

   Type1 data1_;
   Type2 data2_;
};
// example 2 header:
class Example2 {
   class Impl;
public:
   void publicOperation();
private:
   std::auto_ptr<Example2Impl> impl_;
};
// example2 cpp:
class Example2::Impl
{
public:
   void privateOperation1();
   void privateOperation2();
private: // or public if Example2 needs access, or private + friendship:
   Type1 data1_;
   Type2 data2_;
};

Sie können feststellen, dass ich private (und auch geschützte) Mitglieder mit einem Unterstrich postfixiere. Die PIMPL-Version verfügt über eine interne Klasse, für die die Außenwelt die Operationen nicht einmal sieht. Dadurch bleibt die Klassenschnittstelle vollständig sauber: Es wird nur die reale Schnittstelle angezeigt. Keine Notwendigkeit, über Ordnung zu streiten.

Während der Klassenkonstruktion fallen Kosten an, da ein dynamisch zugewiesenes Objekt erstellt werden muss. Dies funktioniert auch sehr gut für Klassen, die nicht erweitert werden sollen, aber einige Mängel bei Hierarchien aufweisen. Geschützte Methoden müssen Teil der externen Klasse sein, damit Sie sie nicht wirklich in die interne Klasse übertragen können.

Ich neige dazu, dem POCO C ++ Coding Style Guide zu folgen .

Ich denke, es geht nur um Lesbarkeit.

Einige Leute gruppieren sie gerne in einer festen Reihenfolge, sodass Sie beim Öffnen einer Klassendeklaration schnell wissen, wo Sie suchen müssen, z. B. nach öffentlichen Datenmitgliedern.

Im Allgemeinen denke ich, dass die wichtigsten Dinge an erster Stelle stehen sollten. Für 99,6% aller Klassen bedeutet dies ungefähr die öffentlichen Methoden und insbesondere den Konstruktor. Dann kommen ggf. öffentliche Datenelemente (denken Sie daran: Kapselung ist eine gute Idee), gefolgt von geschützten und / oder privaten Methoden und Datenelementen.

Dies ist etwas, das möglicherweise von den Codierungsstandards großer Projekte abgedeckt wird. Es kann eine gute Idee sein, dies zu überprüfen.

In unserem Projekt ordnen wir die Mitglieder nicht nach Zugriff, sondern nach Verwendung. Und damit meine ich, wir bestellen die Mitglieder so, wie sie verwendet werden. Wenn ein öffentliches Mitglied ein privates Mitglied in derselben Klasse verwendet, befindet sich dieses private Mitglied normalerweise irgendwo vor dem öffentlichen Mitglied, wie im folgenden (vereinfachenden) Beispiel:

class Foo
{
private:
  int bar;

public:
  int GetBar() const
  {
    return bar;
  }
};

Hier ist das Element bar angeordnet ist , bevor das Element GetBar () , da die erstere von der letzteren verwendet. Dies kann zu mehreren Zugriffsabschnitten führen, wie im folgenden Beispiel:

class Foo
{
public:
  typedef int bar_type;

private:
  bar_type bar;

public:
  bar_type GetBar() const
  {
    return bar;
  }
};

Der bar_type Mitglied wird vom bar- Mitglied verwendet, siehe?

Warum ist das? Ich weiß nicht, es schien natürlicher, dass Sie, wenn Sie irgendwo in der Implementierung auf ein Mitglied stoßen und mehr Details dazu benötigen (und IntelliSense wieder vermasselt ist), es irgendwo oben von Ihrem Arbeitsplatz aus finden können.

In der Praxis spielt es selten eine Rolle. Es ist in erster Linie eine Frage der persönlichen Präferenz.

Es ist sehr beliebt, öffentliche Methoden an die erste Stelle zu setzen, angeblich, damit Benutzer der Klasse sie leichter finden können. Header sollten jedoch niemals Ihre Hauptdokumentationsquelle sein. Wenn Sie also "Best Practices" auf die Idee stützen, dass Benutzer Ihre Header betrachten, scheint dies für mich die Marke zu verfehlen.

Es ist wahrscheinlicher, dass sich Personen in Ihren Headern befinden, wenn sie die Klasse ändern . In diesem Fall sind sie es sollten sie sich um die private Schnittstelle kümmern.

Was auch immer Sie wählen, machen Sie Ihre Header sauber und einfach zu lesen. Das Wichtigste ist, dass ich leicht alle Informationen finden kann, nach denen ich gerade suche, egal ob ich ein Benutzer der Klasse oder ein Betreuer der Klasse bin.

Es ist sehr hilfreich für die Leute, die Ihre Klasse verwenden, um zuerst die öffentliche Schnittstelle aufzulisten. Es ist der Teil, den sie interessieren und den sie verwenden können. Geschützt und privat können nach folgen.

Innerhalb der öffentlichen Oberfläche ist es praktisch, Konstruktoren, Eigenschaftszugriffs- und Mutatoren sowie Operatoren in unterschiedlichen Gruppen zu gruppieren.

Beachten Sie, dass Sie (abhängig von Ihrem Compiler und Ihrem dynamischen Linker) die Kompatibilität mit früheren Versionen einer gemeinsam genutzten Bibliothek beibehalten können, indem Sie nur das Ende der Klasse (dh das Ende der Schnittstelle) hinzufügen und nichts anderes entfernen oder ändern. (Dies gilt für G ++ und libtool, und das dreiteilige Versionsschema für gemeinsam genutzte GNU / Linux-Bibliotheken spiegelt dies wider.)

Es gibt auch die Idee, dass Sie Mitglieder der Klasse bestellen sollten, um Platzverschwendung aufgrund der Speicherausrichtung zu vermeiden. Eine Strategie besteht darin, Mitglieder von der kleinsten zur größten Größe zu bestellen. Ich habe das weder in C ++ noch in C gemacht.

Insgesamt sollte Ihre öffentliche Benutzeroberfläche vor allem stehen, denn das ist die Haupt- / Einzelsache, an der Benutzer Ihrer Klassen interessiert sein sollten. (In der Realität gilt dies natürlich nicht immer, aber es ist ein guter Anfang.)

Innerhalb dieses Bereichs sind Elementtypen und Konstanten zuerst am besten, gefolgt von Konstruktionsoperatoren, Operationen und dann Elementvariablen.

Stellen Sie die privaten Felder an die erste Stelle.

Bei modernen IDEs lesen die Benutzer die Klasse nicht, um herauszufinden, um welche öffentliche Schnittstelle es sich handelt.

Sie verwenden dafür nur Intelligenz (oder einen Klassenbrowser).

Wenn jemand die Klassendefinition durchliest, liegt dies normalerweise daran, dass er verstehen möchte, wie es funktioniert.

In diesem Fall hilft es am meisten, die Felder zu kennen. Es zeigt Ihnen, was die Teile des Objekts sind.

Kommt ganz auf deine Vorlieben an. Es gibt keinen "richtigen Weg".

Wenn ich C ++ in meinen eigenen Haustierprojekten mache, halte ich persönlich die Konvention ein, dass ich den Zugriffsmodifikator vor jedes Mitglied oder jede Methodendeklaration setze.