Eure Programmierkonventionen ?

PeterTheMaster

tabulatoren sind wirklich doof. kuck dir mal manche codes hier im forum an, die tabs enthalten. da springen immer irgnedwelche zeilen aus der reihe. genauso in word.
weil fuer tabs gibts ueberall etwas andere einstellungen, leerzeichen(bei mir 4 pro tab) sind eindeutig.

ansonsten

class MyCoolClass{
    int myCoolAttribute_;
};
void myCoolFunc();
int myCoolVar;

ungarische notation ist der letzte unsinn.
guter code braucht nur sehr selten kommentare, nur bei komplexen algorithmen oder irgendwelchen fiesen tricks.
und natuerlich alles in englisch.

dimah: was hat volkard gesagt, was dich zu fooBar statt fooBar_ bewegen wird?

Gregor

Original erstellt von <fast>:
wenn du das wirklich mit leerzeichen machst, hast du aber viel zu tun.

Ich stelle natürlich meine IDE so ein, dass sie Tabs automatisch durch Leerzeichen ersetzt! :p

PeterTheMaster

im vs kann man spaces gleich oder nachtraeglich in tabs umwandeln lassen und umgekehrt.

wo geht das in visual studio? ich möchte alle meine quelltextdatei von tabs nach leerzeichen umstellen!

ich machs fast so wie dimah
nur noch:

eindeutige var und klassen namen (nicht z.B. int hanswurst)

int test()
{ //<- die klammer unten und nicht oben
}

immer tabs

if (x)
{
    if (y)
    {
        if (z)
        {
            cout << "hallo";
        }
    }
}

lange funktions definitionen rechtzeitig "teilen"

typdefs nur wenn umbedingt nötig, machen das programm teilweise schwer zum lesen

in klassen:
funktionen zum variablen setzen: setXXX()
funktionen zum variablen lesen: getXXX()
funktionen die bool returnen: isXXX()

ein "richtiger" progger nimmt nicht den windows editor.

davie

Original erstellt von <sigi>:
**```cpp
int test()
{ //<- die klammer unten und nicht oben
}

Weshalb eigentlich? Mir fallen mindestens 2 gute Gründe dagegen ein, und eine Begründung, wann doch...

so finde ich es übersichtlicher.
welche gründe sprechen denn dagegen?

Daniel E.

Original erstellt von Gregor:
Hast du dir schonmal Code mit Tabulatoren im Windows-Editor angeguckt? ...oder in einem anderen einfachen Editor?

Dann machs richtig:

for (std::vector<int>::const_iterator it = v.begin (), et = v.end ();
^      it != et; ++it) {
|  ^^^`---------------------------------\
|   h (f (*it), g (*it)); i (*it);       |
| }^                                     |
|^ |                                     |
Tabs                                     Leerzeichen

Ich hatte mit meinen Codes noch nie Probleme sie mit irgendeinem Editor (ed bis kedit) zu bearbeiten. Das können Leute auch lesen, die lieber 1, 4 oder 8 Tabs breit lesen. Mit Leerzeichen zwingt man dem Leser hingegen seinen 'Programmierstil' auf.

Gregor

Welche Gründe sprechen für Tabs?

quellcode nimmt weniger speicherplatz weg

davie

naja Gründe...
[cpp]
int bar () { //OK, Definition
int bar (); //OK, Deklaration

int bar () //was jetzt? ";" vergessen, oder "{" in der nächsten Zeile?
/*Mit meinem System eindeutig!*/

oder:

for (blablablasuperduperiterator i = stdcontainer.begin(); i != stdcontainer.end(); ++i);
{
copy (superduperdideldum);
setSmoking (NULL);
}

Na, Fehler gefunden?

mit

for (int x = 0; x < 100; ++x) {
passiert das nicht![/cpp]

Der zweite Grund kommt von PeterTheMaster ( ):

for (;;) {
/*hier kannst du leichter dinge reinkopieren*/
}

Original erstellt von Gregor:
Welche Gründe sprechen für Tabs?

die lesbarkeit des programms

int test(){
cout << "na";
cout << "wie gehts";
if (a){
cout << "gut";
}
}

na dann viel spaß, wenn du mal eine { bzw. } vergessen hast
das mit den speicherplatz ist ja wohl kein argument, die paar bytes verkraftet die 50GB platte auch noch.

Gregor

@ Daniel E. :
Ich verstehe nicht, was du mir mit folgendem sagen willst :

for (std::vector<int>::const_iterator it = v.begin (), et = v.end ();
^      it != et; ++it) {
|  ^^^`---------------------------------\
|   h (f (*it), g (*it)); i (*it);       |
| }^                                     |
|^ |                                     |
Tabs                                     Leerzeichen

*grimmsen**

Original erstellt von Gregor:
Welche Gründe sprechen für Tabs?

Schau dir mal Python an. Da werden Anweisungsblöcke an Tabs erkannt, es gibt weder geschweifte Klammern noch begin...end. Es wäre gut für jede Programmiersprache, wenn man zum Strukturieren gezwungen wird. In einen Python-Code steigt man x-mal schneller rein als in einen schlechten Code der in anderen Programmiersprachen gemacht wurde.

Daniel E.

[TAB]for[Leerzeichen](std::vector<int>::const_iterator[Leerzeichen]it[Leerzeichen]=v.begin[Leerzeichen](),[Leerzeichen]et[Leerzeichen]=[Leerzeichen]v.end[Leerzeichen]();[Zeil enumbruch]
[TAB][Leerzeichen][Leerzeichen][Leerzeichen][Leerzeichen]it[Leerzeichen]!=[Leerzeichen]et;[Leerzeichen]++it)[Leerzeichen]{[Zeilenumbruch]
[TAB][TAB]h[Leerzeichen](f[Leerzeichen](*it),[Leerzeichen]g[Leerzeichen](*it)); i (*it);[Zeilenumbruch]
[TAB]}[Zeilenumbruch]

Besser?

Gregor

@ <sigi> : Keine Tabs heißt doch nicht keine Einrückung. Man nutzt sogar normalerweise die Tab-Taste für die Einrückung. Man stellt sich halt nur den Editor so ein, dass er die Tab-Zeichen durch jeweils einige Leerzeichen ersetzt. Das hat den Vorteil, dass der Code überall gleich aussieht.

Wenn einer eine Tab-Breite von 8 hat, dann geht ein Code, der mit einer Tab-Breite von 3 geschrieben wurde bei ihm vielleicht weit über den rechten Rand heraus. Deshalb nutze ich Leerzeichen statt Tabs. Die sind überall gleich breit.

Original erstellt von Noesis:
naja Gründe...
[cpp]
int bar () { //OK, Definition
int bar (); //OK, Deklaration

int bar () //was jetzt? ";" vergessen, oder "{" in der nächsten Zeile?
/*Mit meinem System eindeutig!*/

oder:

for (blablablasuperduperiterator i = stdcontainer.begin(); i != stdcontainer.end(); ++i);
{
copy (superduperdideldum);
setSmoking (NULL);
}

Na, Fehler gefunden?
mit

for (int x = 0; x < 100; ++x) {
passiert das nicht![/cpp]

die deklarationen werden sowieso vom quellcode der funktionen getrennt, d.h. sie kommen in die header dateien. also fällt die verwechslung schonmal weg.
die for schleife wird erstmal "am bildschirmrand" geteilt, das ; einer for schleife ist sehr selten (kaum braucht man eine schleife ohne "inhalt" und wenn, dann ne while und keine for)

Der zweite Grund kommt von PeterTheMaster ( ):
for (;;) {
/*hier kannst du leichter dinge reinkopieren*/
}
[/QB]

das kann man doch hier besser:

for (;;)
{
    //da rein
}

also, alles im allen noch kein wirklich überzeugender grund das anders zu machen

davie

Ja einrücken tu ich sowieso:

int SmokerZone () {
//Kannst ja trotzdem eine Leerzeile machen...
   if (Kiffer) {

     joinTheGrasCommunity ();
     bool t = Kiffer;
     t = Kiffer && (t || t && !Kiffer);
     t = t ? Kiffer : t;

   } else if (Nikotiner) {

     joinTheKubaCommunity ();

     if (isCommunism)
        isCommunism = (isCommunism != Kiffer) ? true : !Kiffer;

     int Was = (Nikotiner != Kiffer) ? GESCHNALLT : KOMMUNIST;

     throw "Oh, oh revolution!";
   }
}

[ Dieser Beitrag wurde am 28.11.2002 um 21:56 Uhr von Noesis editiert. ]

davie

Original erstellt von <sigi>:
**
die deklarationen werden sowieso vom quellcode der funktionen getrennt, d.h. sie kommen in die header dateien. also fällt die verwechslung schonmal weg.**

Vorwärts-Deklarationen

Gregor

Original erstellt von Daniel E.:
**
Besser? :)**

Ja, OK! Jetzt hat es "Klick" gemacht. ...aber beim ersten Code. Das Problem hatte ich zuerst garnicht gesehen. ...das hat man natürlich mit Leerzeichen nicht. Da braucht man nichts "richtig machen". Es ist automatisch richtig. :p

Mir kam es mehr darauf an, dass man mit dem falschen Editor und Tabs schnell mal rechts aus dem Bildschirm rauskommt.

[ Dieser Beitrag wurde am 28.11.2002 um 22:04 Uhr von Gregor editiert. ]