Bei mir würde das in etwa so ausschauen:
Code: Alles auswählen
// -> Header
#ifndef KLASSEN_NAME_HPP_ // maybe also prefixed by NAMESPACE_NAME_
# define KLASSEN_NAME_HPP_
/**
* Really usefull class which represents just a sample class and really not more
*/
class Klassenname:
public Basis1,
public Basis2
{
public:
/**
* Initialize class by using member1 for foretell the weather and member2
* for calulating a really cool number.
*
* @param member1
* @param cool_value
*/
Klassenname(int member1, int cool_value);
/**
* Do some public thing...
*
* @param a Blah bla
* @param b Another one...
* @return The number of atoms your brain consits of
*/
unsigned int publicMethod(unsigned int a, unsigned int b);
/**
* Get the $INSERT_DESCRIPTION_OF_MEMBER1_HERE$ (Depending on case just
* leave description empty)
*
* @return Value of $SOME_MORE_DESCRIPTION$
*/
unsigned int getMember1() const;
/**
* Set the value of $DESCRIPTION$
*
* @remark Do not ever let m1 be 42!!!
* @param m1 New value...
*/
void setMember1(int m1);
/**
* Combined getter and setter
*
* @return Reference to member
*/
int& member1();
// Overloaded getter and setter
/**
* Setter comment
*
* @param m1 asdadasdsadfasf
*/
void member1(int m1);
/**
* Getter comment
*
* @return asdlakj jj
*/
int member1() const;
int _member2; //< Short description
/**
* Long description Long description Long description Long descri pton asdas
* Lo ng description Long description Long description Long descrip tion wfa
*/
int const KONSTANTE_1;
protected:
unsigned int protectedMethod( unsigned int a, unsigned int b );
private:
int _member1; //< Blah
/**
* asdasdkasd
*/
void doSomething();
/**
* asjj lkjaskld
*
* @param a kjwad asdölkaösdkasd asd
* @param b aösdköalk sad as
*/
unsigned int privateMethod(unsigned int a, unsigned int b);
};
#endif // KLASSEN_NAME_HPP_
Code: Alles auswählen
// -> Source File
unsigned int g_globalVariable;
// -----------------------------------------------------------------------------
Klassenname::Klassenname(int member1, int cool_value):
_member1(member1),
_member2(cool_value)
{
doSomething();
}
// -----------------------------------------------------------------------------
int Klassenname::member1() const
{
return _member1;
}
// -----------------------------------------------------------------------------
void Klassenname::setMember(int m1)
{
_member1 = m1;
}
// -----------------------------------------------------------------------------
unsigned int Klassenname::protectedMethod(unsigned int a, unsigned int b)
{
// ...
}
// -----------------------------------------------------------------------------
unsigned int Klassenname::privateMethod(unsigned int a, unsigned int b)
{
// Leerzeilen hier normal nur bei längerem Code.
unsigned int result;
int another_local_var = 3;
result = a + b;
return result;
}
// -----------------------------------------------------------------------------
static unsigned int staticFunction( unsigned int a_summand1,
unsigned int a_summand2 )
{
// Gleiches wie oben.
unsigned int result;
result = aSummand1 + aSummand2;
return result;
}
Doxygen Kommentar im Header, da daraus auch die Dokumentation erstellt wird und man sich im Normalfall auch die Header Files zuerst anschaut um zu sehen wie die Klasse funktioniert. Wenn man bereits im Sourcefile nachschauen muss ist es für eine Beschreibung was die Funktion machen sollte sowie so schon zu spät, da es wohl bedeutet dass weder Funktionsname noch Kommentar genau genug beschrieben haben was eigentlich genau passieren soll.
Natürlich kommen auch Kommentar im Sourcefile vor, aber nur solche die für das Verstehen und nicht das Verwenden des Codes nötig sind. Hier verwende ich dann natürlich auch keinen Doxygenkommentare, mit Ausnahme bei Funktionen und Variablen die im Sourcefile definiert werden (also statisch sind). Alles andere braucht keinen Kommentar mehr, da der ja sowieso bereits im Header vorhanden ist.
Präfix
Präfixe verwende ich sehr sparsam. Auf keinen Fall jedoch Präfixe für den Typ (Ungarische Notation). Member bekommen einfach einen Unterstrich als Präfix, da es kurz ist und praktisch für die Auto-Vervollständigung ist, da man nur einen Unterstrich tippen muss und sofort alle Member aufgelistet bekommt. Außerdem kommt es so zu keinen Kollisionen mit Namen für lokale Variablen und Funktionsparameter. Ansonsten bekommen noch globale Variablen, wenn überhaupt welche vorkommen ein g_ davor.
Getter und Setter bekommen ein get- bzw. set-Prefix, um klar zu stellen dass es sich um Getter/Setter handelt. Nicht jeder weiß alle Membernamen um sagen zu können was ein Getter/Setter ist und was nicht. Für boolsche Werte und Flags verwende ich aber durchaus auch is/has/etc. Ausnahmen gibt es aber Vereinzelt auch wie zb x(), y(), z() bei Vektoren...
Groß-/Kleinschreibung
Klassen, Strukturen und allgemein Typen CamelCase, Funktionen firstSmallCamelCase() und Variablen small_with_underscore. Konstanten komplett GROSS, egal ob durch const, define oder enum. Das verhindert komplett Kollisionen zwischen Typ-, Funktions-, Variablen- und Konstantennamen. Makros ebenfalls CAPITALS.
