spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

- Welche "Standard-Funktionen" verwendet ihr? Init - Run - Quit/Exit? - Free - Load - Unload - Move - Update - Render usw.? - Zwischen den Namen gibt es kleine Bedeutungsunterschiede. Ich nehme das was gerade am sinnvollsten ist.

- Benutzt ihr den Kon- und/oder Destruktoren? Oder macht ihr alles über Init/Quit (oder Exit?) Wenn es geht benutze ich Konstruktoren, dafür sind sie doch da
- Wann überladet ihr eine Funktion? Übeladet ihr Kon/Destruktoren)? Wenn es Sinn macht, Ja.
- Benutzt ihr Präfixe (ungarische Notation)? Nein, ich achte eher daraud Aussagekräftige Bezeichnungen zu wählen, AuchWennDieseDannMalWasLängerWerden.
- Setzt ihr Leerzeichen vor die Parameter-Klammer oder komt sie gleich nach dem Funktionsnamen? Keins
- Wann übergebt ihr Werte an Funktionen und wie? Zeiger, Werte oder Referenzen? Das was gerade am meisten Sinn macht.
- Wie lasst ihr euch Werte zurückgeben? Zeiger oder return? Das was gerade am meisten Sinn macht
- Setzt ihr geschweifte Klammern auch bei einzeiligen if(oder anderen)-Schleifen? So wie es übersichtlicher ist. Wenn nur nen return drin steht lasse ich die Klammern meist einfach weg
- Wann setzt ihr Tabulatoren? Auch bei case von switch (VC macht ja keinen Tabulator)? Vor das case nicht. Sonst eben wie üblich
- Wann und Wo setzt ihr Kommentare? Wie oft? Wie ausführlich? Was beschreibt ihr? Ich schreibe Dokumentationen zu Klassen und dem öffentlichen Interface. Im Code selbst eher selten, höchstens eine Erklärung zu ekeligen Hacks
- Wie viel Abstand lasst ihr zwischen Code-Zeilen oder zwischen Funktionsdefinitionen (wegen der Übersichtlichkeit)? Naja.. so wie es gerade Übersichtlich ist.. Ich fasse meine Codezeilen meist logisch etwas zusammen
- NULLt ihr alle eure Zeiger erst? Soll man das überhaupt? Wenn ich sie nicht direkt zuweise, meist ja. Sonst hat man beim delete ein problem
- Wie baut ihr eure Variablen- und Funktionsnamen auf (mit einem System?) CamelCase für alles. Variablen beginnen klein, der rest groß.
- Benutzt ihr ein Logfile oder eine andere Ausgabe? Wann? Warum? Nur für Fehlersuche oder auch einfach zur Info? Nach jeder Funktions-/Variablendeklaration? Nur bei Fehlern oder erfolgreichen Funktionen? Nicht pauschal.
- Welche Rückgabetypen verwendet ihr bei Funktionen (immer bool für Fehler-Abfang oder einfach void (bei der Tribase-Engine gibt es ja den Datentyp tbResult)?) Prüft ihr bei jeder Funktion, ob sie erfolgreich oder nicht war? Ich benutze Exceptions
- Wie fangt ihr Fehler ab? s.o.
- Prüft ihr bei Variablen (insbesondere Zeigern), ob ein gültiger Wert zugewiesen wurde, bzw. z.B. ein Dateipfad gültig ist? JA!!!
- Wann deklariert ihr Klasseninstanzen als Zeiger? Wenn es sinnvoll ist.. (Häuft sich als Antwort irgendwie..)
- Wann packt ihr einen Code-Teil in eine eigene Funktion? Schreibt ihr lieber alles in eine Riesen-Funktion oder habt ihr viele kleine mit ein paar Zeilen Code? Ich habe lieber mehrere kleinere Funktionen, da ich Funktionsnamen quasi als Dokumentation und zur Strukturierung verwende
- Setzt ihr Integer (oder andere Zahlen-Datentypen), die sowieso immer positiv sind, standardmäßig unsigned oder nicht? Ja.
- Benutzt ihr lieber strings oder (const) char*s? std::string
- Deklariert ihr Konstanten über #define, enum oder const? enum oder const, jenachdem was grad Sinn macht
- Wann schreibt ihr Makros? Nur bei Sachen wie SAFE_DELETE oder auch für anderes? Wenn ich sehr häufig wiederholten, unübersichtlichen Code immer und immer wieder schreiben muss aber nicht anders zusammenfassen kann oder als kleine Helper fürs Debugging (Assert, Anhängen von __FILE__, __LINE__ an Fehlermeldungen, etc.
- Inkludiert ihr libs über die Projekteinstellungen oder im Code? Projekteinstellungen da ich meist Cross Plattform arbeite
- Benutzt ihr GameStates oder eine andere Technik? Wenn ja, welche? Naja wenn es sinnvoll ist.. für mein momentanes Projekt brauche ich die nicht.
- Schreibt ihr am Anfang einer Quellcode-Datei, wofür diese zuständig ist, welche Änderungen ihr gemacht habt usw.? Nö. Die Informationen sind alle im SVN.
- Verwendet ihr globale Variablen oder Get/Set-Funktionen mit Membervariablen? Wenn es geht meide ich globals und auch public Variablen. Daher Getter und Setter.
- Welche Funktionen oder Variablen definiert ihr gleich bei der Deklaration bzw. im Header? Getter und Setter und Templatefunktionen natürlich


Ich habe mir mal die Mühe gemacht.. hatte grad nix zu tun
Über ein paar Fragen kann man natürlich streiten, aber das meiste lässt sich eigentlich mit: "So wie es gerade Sinn macht und am Übersichtlichsten ist" beantworten.
Grüße,
Dennis

Ich such mal nur ein paar interessante raus:

- Benutzt ihr Präfixe (ungarische Notation)?
Prinzipiell nicht, ich schreib ein m_ vor Klassenmember und Benutze ansonsten namespaces.

- Setzt ihr Leerzeichen vor die Parameter-Klammer oder komt sie gleich nach dem Funktionsnamen?
Keine Leerzeichen, auch nicht zwischen Operatoren, es sei denn, der Ausdruck wird zu komplex, dann mann man mit Whitespaces mehr Übersicht schaffen.

- Setzt ihr geschweifte Klammern auch bei einzeiligen if(oder anderen)-Schleifen?
Meist nicht.

- Wann setzt ihr Tabulatoren? Auch bei case von switch (VC macht ja keinen Tabulator)?
Ich nehm immer Tabulatoren zur einrücken, es nervt wenn man den Cursor durch 4mal so viele Leerzeichen bewegen muss.

- Wann und Wo setzt ihr Kommentare? Wie oft? Wie ausführlich? Was beschreibt ihr?
Ich benutze Doxygen für wichtige Klassen/Funktionen, in den Funktionen dann auch oft, um irgendwas zu erklären, also prinzipiell schon viele Kommentare (immer noch nicht genug )

- NULLt ihr alle eure Zeiger erst? Soll man das überhaupt?
Sehr selten. Normalerweise werden die im CTor direkt initialisiert, oder ich benutze gleich einen Container, statt Arrays. Aber wenn nicht, wird immer genullt.

- Benutzt ihr ein Logfile oder eine andere Ausgabe? Wann? Warum? Nur für Fehlersuche oder auch einfach zur Info? Nach jeder Funktions-/Variablendeklaration? Nur bei Fehlern oder erfolgreichen Funktionen?
Ich mag Boost::Exception. Die sind echt klasse

- Welche Rückgabetypen verwendet ihr bei Funktionen (immer bool für Fehler-Abfang oder einfach void (bei der Tribase-Engine gibt es ja den Datentyp tbResult)?) Prüft ihr bei jeder Funktion, ob sie erfolgreich oder nicht war?
Auch hier lohnen sich Exceptions, gegebenenfalls Try und Catch Bläcke, oder halt auch mal Returnwerte, was eben gerade Sinn ergibt.

- Wie fangt ihr Fehler ab?
Exceptions

- Wann packt ihr einen Code-Teil in eine eigene Funktion? Schreibt ihr lieber alles in eine Riesen-Funktion oder habt ihr viele kleine mit ein paar Zeilen Code?
Alles was mehrfach benutzt wird, kommt in Funktionen, ansonsten hab ich aber auch shconmal größere Funktionen, die jeweils durch mehrere leere Zeilen und Kommentarlinien gegliedert sind.

- Setzt ihr Integer (oder andere Zahlen-Datentypen), die sowieso immer positiv sind, standardmäßig unsigned oder nicht?
Ja, eigentlich schon. Macht in vielen Situationen einfach Sinn und verringert die Anzahl an Warnungen. Signed benutze ich allerdings nie explizit.

- Benutzt ihr lieber strings oder (const) char*s?
Nur noch std::strings, seit mir vor Jahren ein Programm abgestürzt war, weil der char* zu klein war, seit dem weiß ich, das Strings einfach nur besser sind.

- Wann schreibt ihr Makros? Nur bei Sachen wie SAFE_DELETE oder auch für anderes?
Überall da, wo man mit Templatefunktionen nicht weiterkommt (aber garantiert nicht für sowas wie SAFE_DELETE!!)

- Inkludiert ihr libs über die Projekteinstellungen oder im Code?
Über Projekteinstellungen natürlich

- Schreibt ihr am Anfang einer Quellcode-Datei, wofür diese zuständig ist, welche Änderungen ihr gemacht habt usw.?
Nein, nur manchmal über Klasse, aber da auch keine Änderungen, dafür hat man ja SVN (bzw. bald git).

- Verwendet ihr globale Variablen oder Get/Set-Funktionen mit Membervariablen?
Das sind doch keine Alternativen oO. Globale Variablen, wo es Sinn macht, Get/Set Methoden ungern und eigentlich nie zusammen, dann kann man das auch gleich public machen. Statt SetVariablen nehm ich meist sowas wie DoDamage statt SetHealth.

- Welche Funktionen oder Variablen definiert ihr gleich bei der Deklaration bzw. im Header?
Einzeiler, z.B. Getmethoden.

- Welche "Standard-Funktionen" verwendet ihr? Init - Run - Quit/Exit? - Free - Load - Unload - Move - Update - Render usw.?
Das kommt auf die Klasse und ihren Verwendungszweck an. Im Normalfall habe ich nur eine solche Funktion: update()
Aber bestimmte Klassen haben Funktionen wie: kill(), on_enter(), on_leave etc.

- Benutzt ihr den Kon- und/oder Destruktoren? Oder macht ihr alles über Init/Quit (oder Exit?)
Natürlich benutze ich Konstruktoren; ich halte nicht sonderlich viel von Init Methoden. Im Normalfall wird alles, was wichtig ist vom Ctor gemacht.

- Wann überladet ihr eine Funktion? Übeladet ihr Kon/Destruktoren)?
Immer wenn es notwendig ist. Wenn ich eine Funktion mit verschiedenen Parametern brauche, wird sie überladen. Ctor wird meistens überladen(Copy-Ctor)

- Benutzt ihr Präfixe (ungarische Notation)?
Nein

- Setzt ihr Leerzeichen vor die Parameter-Klammer oder komt sie gleich nach dem Funktionsnamen?
Vor die Klammer nicht aber dahinter: meine_funktion( blubb );

- Wann übergebt ihr Werte an Funktionen und wie? Zeiger, Werte oder Referenzen?
Wenn eine Funktion einen Wert braucht, dann bekommt sie ihn; ob das dann ein Zeiger oder eine Referenz ist(Objekte habe ich egtl. so gut wie nie) hängt vom Objekt ab, das ich übergeben werde.

- Wie lasst ihr euch Werte zurückgeben? Zeiger oder return?
Meistens return.

- Setzt ihr geschweifte Klammern auch bei einzeiligen if(oder anderen)-Schleifen?
Kommt darauf an. Der Übersicht halber manchmal schon, aber manchmal ziehe ich das ganze If-Konstrukt nur in eine Zeile.
Btw: www.if-schleife.de

- Wann setzt ihr Tabulatoren? Auch bei case von switch (VC macht ja keinen Tabulator)?
Im Normalfall lasse ich das VC machen.

- Wann und Wo setzt ihr Kommentare? Wie oft? Wie ausführlich? Was beschreibt ihr?
Kommentare setze ich relativ viele. Bei Stellen, wo ich selbst nicht mehr wissen könnte, wie es funktioniert. Man sagt ja immer, man soll das wieso beschreiben und nicht das wie. Halte ich persönlich für unsinnig. Denn das wie ist oft mal auf den ersten Blick auch nicht gleich zu erkennen(wenn die Funktion irgendwelche Variablen verarbeitet, die von irgendwoherkommen) und daher dient mir ein Kommentar oft als Erinnerung, was diese Funktion mit den Werten egtl. tun sollte.

- Wie viel Abstand lasst ihr zwischen Code-Zeilen oder zwischen Funktionsdefinitionen (wegen der Übersichtlichkeit)?
Zwischen Funktionsdefinitionen bleibt eine Leerzeile, sonst bei Sinnabschnitten mal ne Leerzeile.

- NULLt ihr alle eure Zeiger erst? Soll man das überhaupt?
Kommt darauf an. Temporär erstellte Zeiger nulle ich nicht, sondern initialisiere sie gleich; Membervariablen, werden in der Initialisierungsliste genullt.

- Wie baut ihr eure Variablen- und Funktionsnamen auf (mit einem System?)
Alles klein, Unterstrich zur Trennung einzelner Wörter, Möglichst verständlich, Englisch, private_member_haben_einen_unterstrich_am_ende_

- Benutzt ihr ein Logfile oder eine andere Ausgabe? Wann? Warum? Nur für Fehlersuche oder auch einfach zur Info? Nach jeder Funktions-/Variablendeklaration? Nur bei Fehlern oder erfolgreichen Funktionen?
Im Normalfall reicht mit std::cout um Fehler zu finden.

- Welche Rückgabetypen verwendet ihr bei Funktionen (immer bool für Fehler-Abfang oder einfach void (bei der Tribase-Engine gibt es ja den Datentyp tbResult)?) Prüft ihr bei jeder Funktion, ob sie erfolgreich oder nicht war?
Void bzw. was eben benötigt wird

- Wie fangt ihr Fehler ab?
throw; catch

- Prüft ihr bei Variablen (insbesondere Zeigern), ob ein gültiger Wert
zugewiesen wurde, bzw. z.B. ein Dateipfad gültig ist?
Ja schon; wäre unsicher, wenn man es nicht täte.

- Wann deklariert ihr Klasseninstanzen als Zeiger?
Eigentlich immer. Selten mal ne Referenz.

- Wann packt ihr einen Code-Teil in eine eigene Funktion? Schreibt ihr lieber alles in eine Riesen-Funktion oder habt ihr viele kleine mit ein paar Zeilen Code?
Kommt darauf an. Es kommt in eine eigene Funktion, wenn es Sinn macht. Heißt: Codereduplikation wird vermieden.
Aber wenn eine Funktion mal riesig wird ist es eben so. Wäre nervig, wenn ich sinnnlos zwei Funktionen draus machen würde.
Da fällt mir ein: Ich habe noch einen Codeblock den ich evtl. mal in eine eigene Funktion verschieben kannn

- Setzt ihr Integer (oder andere Zahlen-Datentypen), die sowieso immer positiv sind, standardmäßig unsigned oder nicht?
Kommt darauf an: Wenn immer positiv und dazu da, um Werte abzufangen: unsigned int; gibt aber Fälle, bei denen nutze ich dann ein normales int und setze -1 als Fehler.

- Benutzt ihr lieber strings oder (const) char*s?
Ganz klar strings. Jeder, der gerne chars beutzt ist mir ein Rätsel.Mit strings geht vieles deutlich leichter.

- Deklariert ihr Konstanten über #define, enum oder const?
im Normalfall: const. Enum nutze ich, wenn ein Wert mehrere Konstante Werte annehmen kann, die alle miteinander zusammenhängen.

- Wann schreibt ihr Makros? Nur bei Sachen wie SAFE_DELETE oder auch für anderes?
Ich schreibe egtl. nie Makros. Bisher hatte nichts, was nicht auch durch Templates zu lösen wäre und auch das war sehr wenig.

- Inkludiert ihr libs über die Projekteinstellungen oder im Code?
Im Code...

- Benutzt ihr GameStates oder eine andere Technik? Wenn ja, welche?
GameStates

- Schreibt ihr am Anfang einer Quellcode-Datei, wofür diese zuständig ist, welche Änderungen ihr gemacht habt usw.?
Nö; Dateiname, Datum und Autor stehen bei mir am Anfang.

- Verwendet ihr globale Variablen oder Get/Set-Funktionen mit Membervariablen?
Get/Setfunktionen natürlich und zwar ausschließlich.

- Welche Funktionen oder Variablen definiert ihr gleich bei der Deklaration bzw. im Header?
Keine

Im Grunde hab ich noch keinen vollständig festgelegten Stil, d.h. ich bin bei manchen Sachen noch dabei einen guten Stil für mich zu finden, aber so mache ich das zur Zeit:

- Welche "Standard-Funktionen" verwendet ihr? Init - Run - Quit/Exit? - Free - Load - Unload - Move - Update - Render usw.?
Das was gerade zur Funktion passt.

- Benutzt ihr den Kon- und/oder Destruktoren? Oder macht ihr alles über Init/Quit (oder Exit?)
Normalerweise immer Kon- und Destruktoren.

- Wann überladet ihr eine Funktion? Übeladet ihr Kon/Destruktoren)?
Wenn es Sinn macht

- Benutzt ihr Präfixe (ungarische Notation)?
Ich benutzte Präfixe die den Sinn der Variablen beschreiben. Im Grunde gibt es bei mir 3 Präfixe:
m für Membervariablen
arg falls mir für ein Funktionsargument kein besserer Name einfällt
tmp wenn ich irgendwas kurzzeitig speichere.

- Setzt ihr Leerzeichen vor die Parameter-Klammer oder komt sie gleich nach dem Funktionsnamen?
Kein Leerzeichen

- Wann übergebt ihr Werte an Funktionen und wie? Zeiger, Werte oder Referenzen? Wie es Sinn macht und die Funktion verlangt(wenn diese aus einer externen Bibliothek ist)

- Wie lasst ihr euch Werte zurückgeben? Zeiger oder return?
return

- Setzt ihr geschweifte Klammern auch bei einzeiligen if(oder anderen)-Schleifen?
Kommt drauf an. Im Grunde so wie bei xardias

- Wann setzt ihr Tabulatoren? Auch bei case von switch (VC macht ja keinen Tabulator)?
Das case wird bei mir eingerückt. Das meiste macht aber die IDE automatisch

- Wann und Wo setzt ihr Kommentare? Wie oft? Wie ausführlich? Was beschreibt ihr?
Eigentlich versuche ich im Header den Sinn von Klassen, Variablen und Methoden zu beschreiben. Die Betonung liegt auf versuche :roll:

- Wie viel Abstand lasst ihr zwischen Code-Zeilen oder zwischen Funktionsdefinitionen (wegen der Übersichtlichkeit)?
Normalerweise eine Zeile. Variablen gruppiere ich so wie diese zusammenpassen - gruppieren heiß keine leerzeichen dazwischen.

- NULLt ihr alle eure Zeiger erst? Soll man das überhaupt?
Wenn diese nicht sofort auf das eigentlich Objekt zeigen ja.

- Wie baut ihr eure Variablen- und Funktionsnamen auf (mit einem System?)
CamelCase, wenn Funktionsnamen ein verb (get, set, update) enthalten, dh. es danach noch weiter geht, wird dieses klein geschrieben. Bsp.: setName. Wobei ich hier am überlegen bin ob ich disee nicht doch groß schreibe.

- Benutzt ihr ein Logfile oder eine andere Ausgabe? Wann? Warum? Nur für Fehlersuche oder auch einfach zur Info? Nach jeder Funktions-/Variablendeklaration? Nur bei Fehlern oder erfolgreichen Funktionen?
Bis jetzt hab ich noch nie Logfiles benutzt. Wenn ich mal etwas komplexeres schreibe wäre das aber siche angebracht.

- Welche Rückgabetypen verwendet ihr bei Funktionen (immer bool für Fehler-Abfang oder einfach void (bei der Tribase-Engine gibt es ja den Datentyp tbResult)?) Prüft ihr bei jeder Funktion, ob sie erfolgreich oder nicht war?
Kommt darauf an was die Funktion macht. Solange die Funktion nicht irgendwas anderes zurückgeben soll, bsp. Getter oder Create-Funktionen oder Zustandsabfragen - is, has, gebe ich einen bool zurück falls die Funktion vorzeitig abbrechen kann und dies ein Fehler ist.

- Wie fangt ihr Fehler ab?
Exceptions, falls diese durch Überprüfung der Variablen nicht schon vorher verhindert werden können.

- Prüft ihr bei Variablen (insbesondere Zeigern), ob ein gültiger Wert zugewiesen wurde, bzw. z.B. ein Dateipfad gültig ist?
Ja

- Wann deklariert ihr Klasseninstanzen als Zeiger?
Bei Komplexen Klassen immer Zeiger oder Referenzen

- Wann packt ihr einen Code-Teil in eine eigene Funktion? Schreibt ihr lieber alles in eine Riesen-Funktion oder habt ihr viele kleine mit ein paar Zeilen Code?
Wenn es Sinn macht schreibe ich eine neue Funktion.

- Setzt ihr Integer (oder andere Zahlen-Datentypen), die sowieso immer positiv sind, standardmäßig unsigned oder nicht?
Ja
- Benutzt ihr lieber strings oder (const) char*s?
strings

- Deklariert ihr Konstanten über #define, enum oder const?
Konstante -> const
Enumerationen -> enum

- Wann schreibt ihr Makros? Nur bei Sachen wie SAFE_DELETE oder auch für anderes?
Ich glaube ich habe Makros selten bis nie benutzt.

- Inkludiert ihr libs über die Projekteinstellungen oder im Code?
Projekteinstellungen

- Benutzt ihr GameStates oder eine andere Technik? Wenn ja, welche?
Was sinn macht

- Schreibt ihr am Anfang einer Quellcode-Datei, wofür diese zuständig ist, welche Änderungen ihr gemacht habt usw.?
Nein. Entweder arbeite ich alleine dran oder es gibt SVN

- Verwendet ihr globale Variablen oder Get/Set-Funktionen mit Membervariablen?
Membervariablen mit Getter/Setter

- Welche Funktionen oder Variablen definiert ihr gleich bei der Deklaration bzw. im Header?
Getter, wenn diese nur die Variable zurückgeben und andere Einzeiler. Außerdem alles was nicht anders geht ich aber ich bis jetzt noch nichts mit gemacht habe.

Ich bin aber immer offen für bessere Vorschläge

- Welche "Standard-Funktionen" verwendet ihr? Init - Run - Quit/Exit? - Free - Load - Unload - Move - Update - Render usw.?
Jenachdem was grade am besten passt

- Benutzt ihr den Kon- und/oder Destruktoren? Oder macht ihr alles über Init/Quit (oder Exit?)
Wenn in einer Klasse oder Struktur Zeiger als Privat Member enthalten sind , benutz ich Konstruktoren und Destruktoren

- Wann überladet ihr eine Funktion? Übeladet ihr Kon/Destruktoren)?
Konstruktren und Destruktoren überlade ich meistens nicht
Funktionen relativ oft ( Get und Set werden durch Überladungen ausgetauscht

- Benutzt ihr Präfixe (ungarische Notation)?
Nur die Member einer Klasse bekommen ein kleines M vorrangestellt

- Setzt ihr Leerzeichen vor die Parameter-Klammer oder komt sie gleich nach dem Funktionsnamen?
Leerzeichen werden bei mir selbst vor einem Semikolon geschrieben

- Wann übergebt ihr Werte an Funktionen und wie? Zeiger, Werte oder Referenzen?
Zeiger und Werte aber doch öfters Zeiger
Referezen benutz ich eigentlich fast garnicht

- Wie lasst ihr euch Werte zurückgeben? Zeiger oder return?
Jenachdem

- Setzt ihr geschweifte Klammern auch bei einzeiligen if(oder anderen)-Schleifen?
Jap

- Wann setzt ihr Tabulatoren? Auch bei case von switch (VC macht ja keinen Tabulator)?
Tabulatoren setz ich fast immer

- Wann und Wo setzt ihr Kommentare? Wie oft? Wie ausführlich? Was beschreibt ihr?
Ich kommentiere jede Funktion und in einer Funktion dann die Abschnitte

- Wie viel Abstand lasst ihr zwischen Code-Zeilen oder zwischen Funktionsdefinitionen (wegen der Übersichtlichkeit)?
Kommt drauf an

- NULLt ihr alle eure Zeiger erst? Soll man das überhaupt?
Zeiger werden bei mir immer sofort genullt

- Wie baut ihr eure Variablen- und Funktionsnamen auf (mit einem System?)
Kommt gans darauf an

- Benutzt ihr ein Logfile oder eine andere Ausgabe? Wann? Warum? Nur für Fehlersuche oder auch einfach zur Info? Nach jeder Funktions-/Variablendeklaration? Nur bei Fehlern oder erfolgreichen Funktionen?
Jenachdem was ich grade schreibe benutz ich iostream und eine LogFile
Dabei wird alles ausfürhlich ausgegeben

- Welche Rückgabetypen verwendet ihr bei Funktionen (immer bool für Fehler-Abfang oder einfach void (bei der Tribase-Engine gibt es ja den Datentyp tbResult)?) Prüft ihr bei jeder Funktion, ob sie erfolgreich oder nicht war?
Ich prüfe überall ob es erfolgreich war
Dazu verwende ich aber nicht Bool sondern Int

- Wie fangt ihr Fehler ab?
Jenachdem mit Exceptions oder If Anweisungen

- Prüft ihr bei Variablen (insbesondere Zeigern), ob ein gültiger Wert zugewiesen wurde, bzw. z.B. ein Dateipfad gültig ist?
Meistens schon

- Wann deklariert ihr Klasseninstanzen als Zeiger?
Kommt drauf an

- Wann packt ihr einen Code-Teil in eine eigene Funktion? Schreibt ihr lieber alles in eine Riesen-Funktion oder habt ihr viele kleine mit ein paar Zeilen Code?
Lieber viele kleine

- Setzt ihr Integer (oder andere Zahlen-Datentypen), die sowieso immer positiv sind, standardmäßig unsigned oder nicht?
Sollten keine negativen Zahlen in einer Variable gespeihert werden wird unsigned verwendet

- Benutzt ihr lieber strings oder (const) char*s?
strings

- Deklariert ihr Konstanten über #define, enum oder const?
enum und const

- Wann schreibt ihr Makros? Nur bei Sachen wie SAFE_DELETE oder auch für anderes?
Nie

- Inkludiert ihr libs über die Projekteinstellungen oder im Code?
Projekteinstellungen

- Benutzt ihr GameStates oder eine andere Technik? Wenn ja, welche?
Kommt drauf an

- Schreibt ihr am Anfang einer Quellcode-Datei, wofür diese zuständig ist, welche Änderungen ihr gemacht habt usw.?
Nein

- Verwendet ihr globale Variablen oder Get/Set-Funktionen mit Membervariablen?
Globale Variablen werden bei mir nicht verwendet
Get / Set Funktionen gibts bei mir auch nicht denn dafür verwende ich Überladen von Funktionen

- Welche Funktionen oder Variablen definiert ihr gleich bei der Deklaration bzw. im Header?
Jenachdem

- Welche "Standard-Funktionen" verwendet ihr? Init - Run - Quit/Exit? - Free - Load - Unload - Move - Update - Render usw.?
lediglich move() bei objekten, die objekte im Spiel repräsentieren, der rest ist davon abhängig, wie ich mein projekt strukturiere

- Benutzt ihr den Kon- und/oder Destruktoren? Oder macht ihr alles über Init/Quit (oder Exit?)
ausschließlich c'tors/d'tors -> RAII, zumidnest da, wo's sinnvoll möglich ist

- Wann überladet ihr eine Funktion? Übeladet ihr Kon/Destruktoren)?
den c'tor meistens für copy-, default- und daten-c'tor, wenn sinnvoll, ansonsten eben, wenn die gleiche funktionalität auf unterschiedlichen Parametern aufbauen kann

- Benutzt ihr Präfixe (ungarische Notation)?
nur m_ vor membervariablen, weil mir das ermöglicht, Funktionsparameter (z.B. c'tor) genauso zu nennen.

- Setzt ihr Leerzeichen vor die Parameter-Klammer oder komt sie gleich nach dem Funktionsnamen?
bei klammern nie, nur hinter kommas oder semikola

- Wann übergebt ihr Werte an Funktionen und wie? Zeiger, Werte oder Referenzen?
wenn nur der wert übergeben werden soll, wert bei elementaren datentypen, und const-reference bei Objekten. Zeiger, wenn die variable verändert werden soll, oder wahrscheinlich beim aufrufer auch als zeiger vorliegt

- Wie lasst ihr euch Werte zurückgeben? Zeiger oder return?
in der regel return, Zeiger wenn ein bereits vorhandenes objekt 'bearbeitet' werden soll (wobei das so selten ist, das mir grade kein beispiel einfällt)

- Setzt ihr geschweifte Klammern auch bei einzeiligen if(oder anderen)-Schleifen?
nein. einzeiler ohen geschweifte klammer, immer

- Wann setzt ihr Tabulatoren? Auch bei case von switch (VC macht ja keinen Tabulator)?
ich lasse in der regel VC machen

- Wann und Wo setzt ihr Kommentare? Wie oft? Wie ausführlich? Was beschreibt ihr?
ich kommentiere in der regel klassen als ganzes, und funktionen, deren Bedeutung sich nicht aus name erschließt, bzw. wo man bei den paramtern etwas beachten muss, und im Quellcode dann besonders unübersichtliche Stellen

- Wie viel Abstand lasst ihr zwischen Code-Zeilen oder zwischen Funktionsdefinitionen (wegen der Übersichtlichkeit)?
zwischen funktionsdefinitionen, klassen und sinnabschnitten eine leerzeile, ansonsten nix

- NULLt ihr alle eure Zeiger erst? Soll man das überhaupt?
nur wenn ich sie am punkt der allokation nciht sinnvoll füllen, und nicht zu einem sinnvolelren zeitpunkt allokieren kann

- Wie baut ihr eure Variablen- und Funktionsnamen auf (mit einem System?)
innerhalb eines projekts hab ich ein system (manchmal aber uach mehrere für unterschieldiche "arten" von funktionen) aber kein einheitliches, halt imemr so, wie's mir am logischsten erscheint, und einigermaßen konsistent bleibt. allerdings durchgehend englisch

- Benutzt ihr ein Logfile oder eine andere Ausgabe? Wann? Warum? Nur für Fehlersuche oder auch einfach zur Info? Nach jeder Funktions-/Variablendeklaration? Nur bei Fehlern oder erfolgreichen Funktionen?
ausgaben ausschließlich bei fehlern, oder besser gesagt, wenn ich die entsprechende exception fange, dann je nach system entweder cout oder MessageBox

- Welche Rückgabetypen verwendet ihr bei Funktionen (immer bool für Fehler-Abfang oder einfach void (bei der Tribase-Engine gibt es ja den Datentyp tbResult)?) Prüft ihr bei jeder Funktion, ob sie erfolgreich oder nicht war?
das, was die funktion als ergebnis hat, oder eben void. bei externen funktionen, die ncith ausschließlcih exceptions werfen, ja

- Wie fangt ihr Fehler ab?
wenn er auftritt, wird ne exception geworfen, eventl. unterwegs mit zusatzinformationen versehen (boost::exception ist da toll) und gefangen, wenn man sie irgendwie sinnvoll verarbeiten kann, oder eben, bevor das Programm von ner unbehandelten Ausnahme abgeschossen wird, um noch ne fehlermeldung zu bringen

- Prüft ihr bei Variablen (insbesondere Zeigern), ob ein gültiger Wert zugewiesen wurde, bzw. z.B. ein Dateipfad gültig ist?
normalerweise stell ich sicher, das sie das sind (private member), oder erwarte das bei funktionsparametern. ausnahme sind Datenklassen, z.b. IDs, die auch bewusst ungültige werte annahmen dürfen, oder Zeiger, die gleichzeitig als Flag fungieren, ob ein bestimtmes objekt überhaupt existiert

- Wann deklariert ihr Klasseninstanzen als Zeiger?
wenn sie
a) wegen (noch) fehlender Daten nicht in der initialisierungsliste intialisiert werden könne (member)
b) wenn sie polymorph sind
c) wenn ich sie von eienr funktion als zeiger erhalte, bzw. in eienr erzeuge

- Wann packt ihr einen Code-Teil in eine eigene Funktion? Schreibt ihr lieber alles in eine Riesen-Funktion oder habt ihr viele kleine mit ein paar Zeilen Code?
wenn er semantisch abgegrenzt ist, und von min. zwei anderen funktionen verwendet wird

- Setzt ihr Integer (oder andere Zahlen-Datentypen), die sowieso immer positiv sind, standardmäßig unsigned oder nicht?
vorzeichenlose variablen sind unsigned.

- Benutzt ihr lieber strings oder (const) char*s?
strings

- Deklariert ihr Konstanten über #define, enum oder const?
const, wenns ein einzelner wert ist, enum, wenn's mehrere werte, z.B. für ne variable sind, und define nie

- Wann schreibt ihr Makros? Nur bei Sachen wie SAFE_DELETE oder auch für anderes?
so selten wie möglich

- Inkludiert ihr libs über die Projekteinstellungen oder im Code?
Projekteinstellungen

- Benutzt ihr GameStates oder eine andere Technik? Wenn ja, welche?
abhängig vom spiel entweder gamestates oder ein (anfangs leeres) Spiel mit einblendbarem hauptmenü

- Schreibt ihr am Anfang einer Quellcode-Datei, wofür diese zuständig ist, welche Änderungen ihr gemacht habt usw.?
in Quellcode-dateien nur name, und welcher header/klasse von ihr implementiert wird. bei headern name und kurze beschreibung des inhalts/zwecks

- Verwendet ihr globale Variablen oder Get/Set-Funktionen mit Membervariablen?
ausschließlich letzteres

- Welche Funktionen oder Variablen definiert ihr gleich bei der Deklaration bzw. im Header?
variablen: nur lokale (bei klassenmembern geht das ja auch schlecht, udn globale gibt's net)
funktionen: funktionen, die problemlos in eine zeile passen (inlines im doppelten sinne )

Zitat von »"idontknow"«

Hier hat ja iwer geschrieben, man kann anstelle vo Makros wie Safe_Delete auch template Klassen verwenden :O

ALlg. erklärung pls versteh nicht wie man bestimmte Makros so ersetzen kann *neugierigsei* :p

Das wäre das Äquivalent. Auch wenn das Überprüfen auf einen 0 Zeiger keinen Sinn macht, da delete auf 0 kein Problem ist und jeder andere Fall rein gar nichts abfängt. Sprich man kann das mit dem Safe_Delete gleich wieder verwerfen, da man eh nur delete hat. (Aussser man will da ev. noch was mitloggen, aber dann empfhielt sich eher die Überladung der Operatoren).

Zur Erklärung, wie man Makros ersetzt:
Makros sind oftmals ja dazu genutzt, um Code unabhängig von Typen generisch zu halten, aber da templates genau für das da sind, kann man den Code fast 1:1 übernehmen. (mit template Syntax wohlgemerkt).
Tatsächlich sind templates und Makros sogar sehr ähnlich, aber templates bieten einiges mehr an Sicherheit und ermöglichen Sachen, die mit Makros nicht möglich wären. Zur weiteren Diskussion, was an Makros so schlecht ist z.B hier:
http://www.parashift.com/c++-faq-lite/inline-functions.html#faq-9.5

Ich denke, dass man als Faustregel sagen kann, dass Makros lediglich für Sachen benutzt werden sollen, die _wirklich_ Textersetzung und vor dem Kompilierungsprozess statt finden sollen. (Natürlich Header Guards eingeschlossen).

- Welche "Standard-Funktionen" verwendet ihr? Init - Run - Quit/Exit? - Free - Load - Unload - Move - Update - Render usw.?
Move, Render
- Benutzt ihr den Kon- und/oder Destruktoren? Oder macht ihr alles über Init/Quit (oder Exit?)
ctor + dtor
- Wann überladet ihr eine Funktion? Übeladet ihr Kon/Destruktoren)?
wenn sie ihre daten auf mehrere ähnliche weisen bekommen kann (ID3DXMesh vs IDirect3DVertexBuffer + ibuffer)
- Benutzt ihr Präfixe (ungarische Notation)?
nein
- Setzt ihr Leerzeichen vor die Parameter-Klammer oder komt sie gleich nach dem Funktionsnamen?
keine leerzeichen
- Wann übergebt ihr Werte an Funktionen und wie? Zeiger, Werte oder Referenzen?
interfaces als zeiger, rest referenz

- Wie lasst ihr euch Werte zurückgeben? Zeiger oder return?
am liebsten return
- Setzt ihr geschweifte Klammern auch bei einzeiligen if(oder anderen)-Schleifen?
nur, wenn sie sich innerhalb einer geklammerten schleife/if befinden
- Wann setzt ihr Tabulatoren? Auch bei case von switch (VC macht ja keinen Tabulator)?
vc macht tabs. ohne kann ich nicht mehr
- Wann und Wo setzt ihr Kommentare? Wie oft? Wie ausführlich? Was beschreibt ihr?
kommentare? selten.
- Wie viel Abstand lasst ihr zwischen Code-Zeilen oder zwischen Funktionsdefinitionen (wegen der Übersichtlichkeit)?
alles was ein neues zwischenprodukt berechnet, bekommt ne leerzeile
- NULLt ihr alle eure Zeiger erst? Soll man das überhaupt?
wenn dann mit 0. auch nur im ctor
- Wie baut ihr eure Variablen- und Funktionsnamen auf (mit einem System?)
meist kurze beschreibung. CreateWindowFromParams
- Benutzt ihr ein Logfile oder eine andere Ausgabe? Wann? Warum? Nur für Fehlersuche oder auch einfach zur Info? Nach jeder Funktions-/Variablendeklaration? Nur bei Fehlern oder erfolgreichen Funktionen?
nur für fehler. meist reicht der debugger aus
- Welche Rückgabetypen verwendet ihr bei Funktionen (immer bool für Fehler-Abfang oder einfach void (bei der Tribase-Engine gibt es ja den Datentyp tbResult)?) Prüft ihr bei jeder Funktion, ob sie erfolgreich oder nicht war?
meist eine globale fehlervariable. prüfen tue ich nur solange die funktion fehlschlägt, danach gilt sie als getestet
- Wie fangt ihr Fehler ab?
Fehler? was ist das? (meist ein if oder assert())
- Prüft ihr bei Variablen (insbesondere Zeigern), ob ein gültiger Wert zugewiesen wurde, bzw. z.B. ein Dateipfad gültig ist?
nur auf != 0, den rest macht die File-klasse
- Wann deklariert ihr Klasseninstanzen als Zeiger?
wenn ich ein interface dazu habe, oder ich das teil mehreren modulen zur verfügung stelle
- Wann packt ihr einen Code-Teil in eine eigene Funktion? Schreibt ihr lieber alles in eine Riesen-Funktion oder habt ihr viele kleine mit ein paar Zeilen Code?
tendiere zu großen funktionen, die ich nach und nach in ein framework auslagere
- Setzt ihr Integer (oder andere Zahlen-Datentypen), die sowieso immer positiv sind, standardmäßig unsigned oder nicht?
alles unsigned. schleifenvariable immer!
- Benutzt ihr lieber strings oder (const) char*s?
als literale const char*, als parameter std::string &
- Deklariert ihr Konstanten über #define, enum oder const?
const oder enum
- Wann schreibt ihr Makros? Nur bei Sachen wie SAFE_DELETE oder auch für anderes?
sogar safe_delete ist überflüssig, delete 0; ist gültig
- Inkludiert ihr libs über die Projekteinstellungen oder im Code?
code. (#pragma)
- Benutzt ihr GameStates oder eine andere Technik? Wenn ja, welche?gamestates
- Schreibt ihr am Anfang einer Quellcode-Datei, wofür diese zuständig ist, welche Änderungen ihr gemacht habt usw.?
der dateiname ist eindeutig genug
- Verwendet ihr globale Variablen oder Get/Set-Funktionen mit Membervariablen?
Get/Set
- Welche Funktionen oder Variablen definiert ihr gleich bei der Deklaration bzw. im Header?
mathematische funktionen oder einfache konvertierungsfunktionen. für variablen gibt es getter + setter