Also:

Main.cpp

// Main.cpp
// C++ Header...
#include <iostream>

//Eigene Header...
#include "Klasse.hpp"

using namespace std;

int main()
{
    // Code...
}

Klasse.hpp

// Klasse.hpp
#ifndef _KLASSE_HPP_
#define _KLASSE_HPP_

// C++ Header

// Eigene Header

// Makros...

class Klasse
{
private:
    // Eigenschaften...
public:
    // Methoden...
};

#endif

// Notizen...

Klasse.cpp

// Klasse.cpp

// C++ Header.

// Header wo die Prototypen sich befinden.
#include "Klasse.hpp"

// Eigene Header.

using namespace std;

//----------> Konstruktoren <----------//
//----------> Destruktoren <----------//
//----------> Getter <----------//
//----------> Inserter <----------//
//----------> Löscher <----------//
//----------> Operatoren <----------//
//----------> Prüfer <----------//
//----------> Setter <----------//
//----------> Andere <----------//
//---------->> ENDE <<----------//

Wie findet ihr das?

Mfg Wikinger75!

Ein was stört micht. NIEMALS in Headerdateien ein using namespace std; .Ansonsten schön Kommentiert, übersichtlich, gefällt mir.

Hat er ja auch nicht..

Ob es wirklich gut ist sieht man eigentlich erst, wenn man viel Code hat, aber ich denke, dass das kein schlechter Ansatz ist..

EDIT:
Doch was. Fang keine Namen mit einem Unterstrich an. Die sind für dem Compiler reserviert.

//----------> Destruktoren <----------//

Wie findet ihr das?

Wie findet ihr das?

ist unfug.
generell nett ist es, die konstruktoren, zuweisungsoperatoren destruktoren beisammen stehen zu haben, und zwar als erste publicsachen. und gleichartige sachen auch zusammen. das war's aber dann auch.

Was ich zu deinem Stil sagen würde? Jojo, ist in Ordnung, meiner ist besser :p
Und ich werde meinen jetzt nicht präsentieren, das führt zu nichts.

Grüssli

Ich gratuliere, du hast gerade die Büchse der Pandora geöffnet.

Hab ich doch gern gemacht^^.

Was ich zu deinem Stil sagen würde? Jojo, ist in Ordnung, meiner ist besser :p
Und ich werde meinen jetzt nicht präsentieren, das führt zu nichts.

Dazu sag ich jetzt nur mal lol^^

@drakon

EDIT:
Doch was. Fang keine Namen mit einem Unterstrich an. Die sind für dem Compiler reserviert.

Danke für den Tip^^

@thema
Danke für euer antworten Leuts.

class Class_Name
{
    private:
        //Eigenschaften
    public:
        //Methoden
};

//statt

class Class_Name
{
private:
    //Eigenschaften
public:
    //Methoden
};

Und achte ein wenig mehr auf die Rechtschreibung:
Schreib still -> Schreibstil
lessbar -> lesbar
interesieren -> interessieren
Und natürlich Frage, Neugier, Anfang alles gross.

class Sample
{
   int attribute;

   int getAttribute() const
   {
      return attribute;
   }

   void setAttribute( int attrib )
   {
      attribute = attrib;
   }
};

Sowas mache ich inline, also direkt in der Klassendefinition. Ansonsten finde ich die Worte Getter und Setter ungeeignet da sie irreführend sind. Man möchte das Modell das eine Klasse modelliert manipulieren und nicht die Implementierung. Daher gibt es bei mir nur drei Kategorien: public interface, protected interface und private interface.
Implementierungsdetails versuche ich so weit wie möglich zu kapseln, das heißt im Idealfall muss ich nur ein paar private Methoden ändern. Man sollte allerdings nicht vergessen, dass die Implementierung für den Anwender durchaus wichtig sein kann was Laufzeitverhalten angeht, zum Debuggen ist es schön den Quellcode zu haben, etc.

Erst die public-Sachen, dann private... Den Benutzer kann ja nur das public interessieren

Erst die public-Sachen, dann private... Den Benutzer kann ja nur das public interessieren

Interessant, ich mache immer privat zuerst weil den Leser des Source Codes kann ja nur die interna interessieren - das public interface steht ja in der doku

Aquae schrieb:

Erst die public-Sachen, dann private... Den Benutzer kann ja nur das public interessieren

Interessant, ich mache immer privat zuerst weil den Leser des Source Codes kann ja nur die interna interessieren - das public interface steht ja in der doku

Interessant, bei mir steht private am Schluss, weil das interessiert garantiert niemanden, denn da steht nur ein KlassePrivate d;*

Kommentare ala "Konstruktoren", "Destruktor", "Public Methoden" lass ich weg. Denn mit der Dokumentation der Methoden gehen diese Kommentare eh unter/machen den Header nicht übersichtlicher

Wichtiger ist mir da eher eine gewisse Konsistenz im Interface (Methodenbenennungen, Klammersetzung im Source, Einrückung (Tab vs Leerzeichen) usw)

Aquae schrieb:

Erst die public-Sachen, dann private... Den Benutzer kann ja nur das public interessieren

Interessant, ich mache immer privat zuerst weil den Leser des Source Codes kann ja nur die interna interessieren - das public interface steht ja in der doku

Das sehen viele OS-Entwickler (leider) anders. Da ist das public Interface die Doku.

Shade Of Mine schrieb:

Aquae schrieb:

Erst die public-Sachen, dann private... Den Benutzer kann ja nur das public interessieren

Interessant, ich mache immer privat zuerst weil den Leser des Source Codes kann ja nur die interna interessieren - das public interface steht ja in der doku

Das sehen viele OS-Entwickler (leider) anders. Da ist das public Interface die Doku.

Stimmt, das kann ich auch nicht verstehen. Und ich rede hier nicht von Projekten wo der Author den Code möglichst unzugänglich machen wollte, sondern von richtigen OSS-Projekten wie XFCE.

Was ich auch immer wieder erstaunlich finde: man findet nirgends in einem Header-File ganz oben einen Kommentar der kurz erklärt was in der Datei ist. Im Regelfall steht dort nur der Copy 'n Paste GPL Text.
Kann ich echt nicht nachvollziehen.

Interessant, bei mir steht private am Schluss, weil das interessiert garantiert niemanden, denn da steht nur ein KlassePrivate d;*

Ah und in KlassePrivate steht ein KlassePrivatePrivate* d; ?

franz schrieb:

Interessant, bei mir steht private am Schluss, weil das interessiert garantiert niemanden, denn da steht nur ein KlassePrivate d;*

Ah und in KlassePrivate steht ein KlassePrivatePrivate* d; ?

Ich schätze mal, er auf das Handle-Body-Idiom anspricht, und dass außer einer Forward-Deklaration nichts von KlassePrivate im Header zu sehen ist.

und dass außer einer Forward-Deklaration nichts von KlassePrivate im Header zu sehen ist.

Exakt. Aber Handle-Body-Idiom kannte ich noch nicht, mir ist das als "Pimpl" bekannt.

Ich schätze mal, er auf das Handle-Body-Idiom anspricht, und dass außer einer Forward-Deklaration nichts von KlassePrivate im Header zu sehen ist.

Mir durchaus bewusst, aber das beantwortet die Frage nicht:
man hat Klassen die private Member und Funktionen haben - zB eben die Impl-Klasse.

Und wie sieht es dort aus?

Tachyon schrieb:

Ich schätze mal, er auf das Handle-Body-Idiom anspricht, und dass außer einer Forward-Deklaration nichts von KlassePrivate im Header zu sehen ist.

Mir durchaus bewusst, aber das beantwortet die Frage nicht:
man hat Klassen die private Member und Funktionen haben - zB eben die Impl-Klasse.

Und wie sieht es dort aus?

Das braucht einen (als Anwender) nicht zu interessieren. Das ist ja, neben der Reduzierung der Compilezeit, der Sinn der Sache.

Shade Of Mine schrieb:

Tachyon schrieb:

Ich schätze mal, er auf das Handle-Body-Idiom anspricht, und dass außer einer Forward-Deklaration nichts von KlassePrivate im Header zu sehen ist.

Mir durchaus bewusst, aber das beantwortet die Frage nicht:
man hat Klassen die private Member und Funktionen haben - zB eben die Impl-Klasse.

Und wie sieht es dort aus?

Das braucht einen (als Anwender) nicht zu interessieren. Das ist ja, neben der Reduzierung der Compilezeit, der Sinn der Sache.

Dann bist du nicht besser als die Leute bei vielen OS Projekten. Denk doch auch mal an andere Programmierer (in deinem Team).

Tachyon schrieb:

Shade Of Mine schrieb:

Tachyon schrieb:

Ich schätze mal, er auf das Handle-Body-Idiom anspricht, und dass außer einer Forward-Deklaration nichts von KlassePrivate im Header zu sehen ist.

Mir durchaus bewusst, aber das beantwortet die Frage nicht:
man hat Klassen die private Member und Funktionen haben - zB eben die Impl-Klasse.

Und wie sieht es dort aus?

Das braucht einen (als Anwender) nicht zu interessieren. Das ist ja, neben der Reduzierung der Compilezeit, der Sinn der Sache.

Dann bist du nicht besser als die Leute bei vielen OS Projekten. Denk doch auch mal an andere Programmierer (in deinem Team).

Die sollten i.d.R. nicht fremden Code bearbeiten, sondern nur die gegebenen Interfaces benutzen. Für alles andere gibt es die Software Design Description. Da stehen auch Implementierungsdetails drin.

Im Übrigen werden die private-Header eh nie mit installiert, so dass eine Verwendung nur möglich ist, wenn man sich den Header aus den sourcen holt (falls diese überhaupt zugänglich sind).

Es geht hier um das Layout des Codes.
Und ich will wissen wie das Layout der Impl Klasse aussieht.

Ein "das hat dich als Anwender nicht zu interessieren" ist eine komplette Themenverfehlung. Genauso wie eine Erklärung des pimpl Idioms...