Geschweifte Klammern

[effe_eichelt]

Bei main() benutzt ich Variante 2, bei allen anderen immer Variante 1.

[unb3kannter]

varante #2.

bei einzeilern variante #5.1:

void twenty_seven()
    { return; }

[DrGreenthumb]

Ich nehme #1 für Schleifen-blöcke etc. und #2 für Funktionen. Manchmal auch #1 bei kleinen Funktion. Bin da etwas unkonsequent.

steff3 schrieb:

sollte es mir zu denken geben das ich als einziger Variante 3 bevorzuge

Definitiv.

[rüdiger]

Ich benutze "One True Brace Style" (also #1)

[Einsiedler]

Sofern die Coding Guideline der Sprache nichts anderes sagt, verwende ich für sämtliche
Typen und Namespaces die #2. Sämtliche restlichen Klammern werden im Stil #1 gesetzt.

[FireFlow]

DrGreenthumb schrieb:

Ich nehme #1 für Schleifen-blöcke etc. und #2 für Funktionen. Manchmal auch #1 bei kleinen Funktion. Bin da etwas unkonsequent

So mach ich es aber auch. Mir gefällts so

[Variante #6]

int i;main(){for(;i["]<i;++i){--i;}"];read('-'-'-',i+++"hell\
o, world!\n",'/'/'/'));}read(j,i,p){write(j/p+p,i---j,i/i);}

[Daniel E.]

kingruedi schrieb:

Ich benutze "One True Brace Style" (also #1)

Naja, die Propheten benutzten in der Bibel für Funktionsklammern aber auch #2. Ich mache das allerdings nur, wenn ich in der Parameterleiste umbrechen muß.

[Gast]

Damit sind wir schon beim nächsten Thema: Wie brecht ihr um?

#1

void foo(int a, int b, int c,
int d, int e)

#2

void foo(int a, int b, int c
         int d, int e)

#3

void foo(int a,
         int b,
         int c,
         int d,
         int e)

[HEZ]

Daniel E. schrieb:

Naja, die Propheten benutzten in der Bibel für Funktionsklammern aber auch #2.

Häh? Ich dachte #1 wär älter... oder was meinst du?

@Optimizer: Mach doch lieber nen neuen Poll auf. Aber wenns sein muss:
#3

void foo(int a, int b, int c
  int d, int e);

[Daniel E.]

HEZ schrieb:

Daniel E. schrieb:

Naja, die Propheten benutzten in der Bibel für Funktionsklammern aber auch #2.

Häh? Ich dachte #1 wär älter... oder was meinst du?

In der Bibel ("The C Programming Language") wird so umgebrochen:

int ret(int blabla)
{
    while (blabla > 0) {
        blabla--;
    }

    return blabla*23;
}

Also so, wie's DrGreenthumb erklärt. Ich betreibe beim Einrücken Gotteslästerung, und mache konsequent #1, außer ich breche die Parameter wie von Optimizer in #2 gezeigt um und setze dann die Klammer auf eine eigene Zeile. Kann man es denn überhaupt anders machen?

[Ben04]

Vergiss folgende aber nicht
#4

int foo(int a,
  int b, 
  ...)

#5

int foo(
  int a,
  int b, 
  ...)

#6

int foo(
  int a,
  int b, 
  ...
)

Ich benutze letztere.

[Gast]

Lasst mal die Klammern unberücksichtigt. Wird zu kompliziert.

[und_noch_was]

Weiterhin sollte man unbedingt nur 2 leerzeichen weit einrücken. Bei 80 Zeichen sollte man die Zeile umbrechen ...

[groovemaster]

Optimizer schrieb:

Wie brecht ihr um?

Also entweder gar nicht oder komplett, also pro Zeile ein Parameter. Und den ersten Parameter in eine neue Zeile. Das ist schöner beim Einrücken, da ich Tabs verwende.

void foo(
    int a,
    int b,
    int c,
    int d,
    int e)

[SG1]

Nene, eingerueckt wird mit Tabs. So kann jeder die Tabstopweite so setzen, wie ers will.

[tsk]

Daniel E. schrieb:

In der Bibel ("The C Programming Language") wird so umgebrochen:

umbrochen

[otze]

ich verwende eigentlich nur variante #1

bei else zweigen begeh ich aber eine sünde und setz die "{" auf ne eigene zeile.

also

if(){

}
else
{

}

[PeterTheMaster]

ich verwende natuerlich nr. 1 und dementsprechend beim parameterliste umbrechen (NUR wenn die zu lang ist) nr. 6, also

void foo(
    int a,
    int b,
    int c,
    int d,
    int e
){
    do1(a,b);
    do2(c,d,e); //wir wollen ja keine unreferenzierten parameter ;)
}

[Gast]

Ich hab vor kurzem was ätzendes gesehen:

if( foo ) {
    ...
} else {
    ...
}

Man muss die formatfreien Sprachen einfach lieben.