Eure Programmierkonventionen ?

rüdiger

Also ich kommentiere auch immer in Englisch. Ich kommentiere aber sehr wenig, da ich denke, dass zu viele Kommentare eher überflüssig sind und man lieber den Code eindeutiger schreiben sollte, die meisten Kommentare verweisen bei mir auf das was noch zu tun ist (fangen mit einem [TODO] an) oder mit Warnungen, wo es später hacken könnte (fangen mit [warning] an), dann kann man einfach mit eingem grep die entsprechenden Zeilen auslesen.

@Marc++us
aber führende _ sind dem Compiler vorbehalten, da bleibt mir nur ein _ am ende, aber da ich das nur für Parameter mal benutze, finde ich es nicht alzu schlimm.

indent ist auch ein Programm zum umformatieren von Source Code, aber Open Source.

volkard

Also ich kommentiere auch immer in Englisch.

und hast keine probleme mit dem finden der allerbesten begriffe?
einer, meiner kommentare, die immer wieder hier landen, ist

//Ein Heap ist ein Binärbaum mit der Bedingung, daß jeder 
    //Knoten kleinergleich seinen beiden Kindern (falls 
    //vorhanden) ist. Diese Implementierung als Array 
    //garantiert außerdem, daß der Baum ballanciert ist. 
    //Einfügen eines beliebeigen Elements und Ausfügen 
    //des kleinsten haben nur logarhitmischen Zeitbedarf. 
    //Weil die Integritätsbedingung schwächer als beim 
    //normalen Binärbaum ist, ist der Heap auch ein wenig 
    //schneller.

was heißt das auf englisch? und: trifft die übersetzung den nagel auf den kopf?

ich gebe ja zu, daß ich englische texte flüssig lesen kann, aber übersetzungen von begriffen wie "Eichmaß", "transitive Hülle", <joke>"kreisfreier zusammenhängender Graph",</joke> "Girokonto" oder "Urvater" fallen mir zu schwer, um auch nur im entferntesten annehmen zu können, es bestünde eine glaubhafte chance, den allerbesten begriff zu wählen, und das geht sowohl den bezeichnern als auch den kommentaren so.

rüdiger

@volkard
ja, so Situationen sind oft kritisch, da muss man sich eben auf sein Wörterbuch verlassen.

rüdiger

BTW.
was mir gerade einfällt, seit ihr Typen, die Leerzeichen zwischen Operanden und Operatoren machen?

Also

a = b + 1;

anstelle

a=b+1;

Also ich mach nur Leerzeichen, falls ich das Gefühl habe, dass es ansonsten wirklich übersichtlich wird

also

if(a&&!b)

da finde ich übersieht man so leicht das wichtige !

volkard

Original erstellt von kingruedi:
@volkard
ja, so Situationen sind oft kritisch, da muss man sich eben auf sein Wörterbuch verlassen.

hast natürlich recht.

das war google.

a heap is a binary tree with the condition that everyone is 
small knot its two children (if available).  In addition this 
implementation as array guarantees that the tree is ballanced. 
inserting one like-own element and deleting the smallest have 
only logarhitmic time requirement.  because the integrity 
condition is weaker than with normal binary tree, is the heap 
also a little faster.

das war ich:

a heap is a binary tree with the condition, that each
knot lowerequal his two children (if available) is.
this implementation as array guarantees in addition, 
that the tree ballaced is. insertion and deletion the 
smallest have only logarithmic time requirement.
becaus the integrity condition weaker as at the normal 
binary tree is, is the heap also a bit faster.

ich werde dennoch darauf setzen, daß nur die besten bezeichner und die besten kommentare gut genug sind.

volkard

Original erstellt von kingruedi:
Also ich mach nur Leerzeichen, falls ich das Gefühl habe, dass es ansonsten wirklich übersichtlich wird

ich auch.

Gregor

Ich mache viele Leerzeichen. Ich bin jemand, der sowas schreibt, wie:

for (int i = 0 ; i < blah ; ++i)
{
   a += (i << 1);
}

volkard

Original erstellt von Gregor:
**Ich mache viele Leerzeichen. Ich bin jemand, der sowas schreibt, wie:
for (int i = 0 ; i < blah ; ++i)
{
   a += (i << 1);
}
**

da fehlen aber noch sechs leerzeichen! so ist das ja total unlesbar!

for ( int i = 0 ; i < blah ; ++ i )
{
   a += ( i << 1 ) ;
}

Gregor

Original erstellt von volkard:
**da fehlen aber noch sechs leerzeichen! so ist das ja total unlesbar!
**

Die mache ich halt nicht. :p Ich habe aber auch schon oft genug Leerzeichen bei Klammern gesehen. Finde ich nicht so schön.

volkard

warum nicht nach inhalt zusammenfassen?

for( int i=0 ; i<blah ; ++i )
{
   a += (i<<1);
}

Gregor

Original erstellt von volkard:
**warum nicht nach inhalt zusammenfassen?
**

Hmmm... Ich habe gerade gesehen, dass das bei mir doch nicht so konsistent ist. Manchmal fasse ich auch nach Inhalt zusammen. Allerdings kommt bei mir immer ein Leerzeichen nach "for" und keins nach "(" und keins vor ")".

Ich mache z.B. auch oft folgendes :

a += array [i+1];

Gerard

ahja ich nutze namespaces zu dokumention, bei den replace wettbewerb habe ich z.b.

namespace Dimah
{
    namespace Private
    {
        template<typename Iter, typename ValueType>
        Iter mutative_find(Iter b, Iter e, const ValueType& v);

        template<typename Iter, typename Pred>
        void duff_for_each(Iter begin, const Iter end, Pred pr);

        namespace WhatAndWithEqSize
        {
            inline std::string & replace(std::string & in, const std::string & what, const std::string & with);
        }

        namespace WhatAndWithSizeOne
        {
            inline std::string & replace(std::string & in, const std::string & what, const std::string & with);
        }

        namespace WhatGreaterAsWith
        {
            inline std::string & replace(std::string & in, const std::string & what, const std::string & with);
        }

        namespace WhatLessAsWith
        {
            inline std::string & replace(std::string & in, const std::string & what, const std::string & with);
        }
    } // namespace Private

    std::string & replace(std::string & in, const std::string & what, const std::string & with)
    {   
        using namespace Dimah::Private;
        if(what.size() == with.size())
        {
            if(what.size() == 1)
                return WhatAndWithSizeOne::replace( in, what, with );
            else
                return WhatAndWithEqSize::replace( in, what, with );
        }
        else 
        {
            if(what.size() > with.size())
                return WhatGreaterAsWith::replace( in, what, with );
            else
                return WhatLessAsWith::replace( in, what, with ); 
        }
    }
} // namespace Dimah

Shade Of Mine

mal ehrlich, warum nicht die Funktion statt

WhatLessThanWith::repleace

lieber

ReplaceWhatLessThanWith

zu nennen.

Das haette den vorteil, dass der anwender direkt das richtige aufrufen kann.

Es ist ja oft so, dass man weiss ob with oder what groesser ist...

Gerard

Der User kann doch auch so die Funktionen Aufrufen, ob er jetzt WhatLessThanWith::repleace oder ReplaceWhatLessThanWith nutzen ist doch egal (eigentlich sollte er keins von beiden).
Dadurch das ich Namespaces nutze kann ich lange Bezeichner wählen ohne dem User die langen Namen aufzuwingen (hier in den bsp kommt es schlecht rüber weil die Funktion nur einmal aufgerufen werden)
außerdem muss der Namespace nicht nur eine Funktion enthalten oder er könne auch ein namespace Private haben usw.

[ Dieser Beitrag wurde am 30.11.2002 um 19:26 Uhr von Dimah editiert. ]

Helium

Wegen der Leerzeichen:
Bei mir eher so:

for (int i=0; i<blah; ++i)
{
   a += (i<<1);
}

Ich finde irgendwie ein Leerzeichen vor einem Semikolon nicht so toll. Aber das ist wohl eine frage des Geschmacks und nicht der Konvention.

Shade Of Mine

Original erstellt von Dimah:
Der User kann doch auch so die Funktionen Aufrufen, ob er jetzt WhatLessThanWith::repleace oder ReplaceWhatLessThanWith nutzen ist doch egal (eigentlich sollte er keins von beiden).

der user muss
Dimah::Private::WhatsLessThanWith::replace
aufrufen!
da ist Dimah::ReplaceWhatsLessThanWith schon besser!

warum sollte er dass denn nicht? da spart er sich doch sinnlose ifs und aufrufe von string::size()

nicht dass das so teuer waere, aber in 90% der Faelle weiss der Anwender ja schon, was groesser ist!

Gerard

Original erstellt von Shade Of Mine:
**der user muss
Dimah::Private::WhatsLessThanWith::replace
aufrufen!
da ist Dimah::ReplaceWhatsLessThanWith schon besser!

warum sollte er dass denn nicht? da spart er sich doch sinnlose ifs und aufrufe von string::size()

nicht dass das so teuer waere, aber in 90% der Faelle weiss der Anwender ja schon, was groesser ist!**

naja ob

Dimah::WhatsLessThanWith::replace
Dimah::ReplaceWhatsLessThanWith

Vom Schreibaufwand ist es doch fast gleich und die Vorteile der namespace Lösung habe ich schon genant.
Jetzt ist die Frage ob Private oder nicht Private, ok in diesen Fall ist der Private teil noch Eingärmassen brauchbar für den User, aber anderseits will ich den User der die lib nutzt und nur einfach replacen will nicht mit unnötigen Details belasten "welches replace brauche ich den?, was ist waht?" und am Ende bringt es ihn nichts messbares.
Der normale User sieht "Private" ah ok weiter brauche ich nicht zu gehen, der User der unnötige size aufrufe sparen will, oh "Private" ;).

kartoffelsack

Funktionsnamen beginnen mit Verb und groß.

Variablen mit Typkennung (angelehnt an ungar. Not. - was daran immer alle so schrecklich finden, versteh ich nicht. ). Member-Variablen mit m_

Klassen mit C, Funktionsklassen mit F (da hat mir noch keiner nen anderen tollen Vorschlag gemacht).

Ansonsten ziehmlich viele Leerzeilen, Zeilenumbrüche. Find ich halt irgendwie übersichtlicher.

Ich rücke zwei Leerzeichen ein.

Variablendeklarationen schreib ich so:

double
  dWert;

d.h. den Typ in eine extra-Zeile und ein Zeichen weiter eingerückt. So find ich die erste Verwendung (Deklaration) einer Variable auf Anhieb. Der eigentliche Auslöser dafür waren aber Templates

std::multimap<CAussageKraeftigerName, FSortierungNachXXXSchema> mpAussageKraeftigeNamen;

is einfach schrecklich.

Ansonsten mach ich Kommentare für Doxygen, wo ichs für nötig finde auch im Code (allerdings formulier ich da wenig aus und achte nich so auf Grammatik etc.).

Alles was Code ist in Englich (Variablennamen etc), Kommentare aber in Deutsch, da sonst die Bereitschaft sinkt, welche zu schreiben.

Mit Namespaces gruppier ich die Klassen, mach die Namespaces aber nie länger als 4 Buchstaben, weil sie sonst zu nervig werden (mach sie normalerweise nicht auf).

[ Dieser Beitrag wurde am 02.12.2002 um 19:32 Uhr von kartoffelsack editiert. ]

davie

Was mit namespace aliases?

kartoffelsack

@dimah

Wenn ich Funktionen innerhalb von ner Bibliothek Privat machen will, schreib ich die in Klassen statt nem namespace und erklär MEINE Klassen zu friends davon.

Dann muss ich mich nicht drauf verlassen, dass der Benutzer meinen Namespace "Privat" respektiert.