Wie setzt ihr Klammern?

[Ingo (Gast)]

Wie setzt ihr eure Klammern bzw. Welche Schreibweise gestaltet sich bei 
viel Code eurer Meinung übersichtlicher?

If (x){
   Bla bla;
}
Oder 
If(x)
{
   Bla bla;
}

ingo

[Peter II (Gast)]

1.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

1.

[Kevin (Gast)]

if x = (brumm, brumm)
then y = (plemm, plemm) else (tschiep, tschiep)

[Ingo (Gast)]

Programmiersprache ist C, hatte ich vergessen...

[HildeK (Gast)]

Ingo schrieb:
> If(x)
> {
>    Bla bla;
> }

ist für mich übersichtlicher.

[Kevin (Gast)]

Kevin schrieb:
> if x = (brumm, brumm)
> then y = (plemm, plemm) else (tschiep, tschiep)

Ingo schrieb:
> Programmiersprache ist C, hatte ich vergessen...

Ach so, na dann,

If (x)
 {
   Krach, Schepper, Bumm;
  )

[trollalala (Gast)]

HildeK schrieb:
> Ingo schrieb:
>> If(x)
>> {
>>    Bla bla;
>> }
>
> ist für mich übersichtlicher.
+1

aber das dürfte eine religiöse Frage wie AVR<->PIC sein...

[J.-u. G. (juwe)]

Kevin schrieb:
> Ach so, na dann,
>
> If (x)
>  {
>    Krach, Schepper, Bumm;
>   )

Ich denke, syntaktisch korrekt sollte es auch sein.

[Markus W. (Firma: guloshop.de) (m-w)]

Ingo schrieb:
> Wie setzt ihr eure Klammern bzw. Welche Schreibweise gestaltet sich bei
> viel Code eurer Meinung übersichtlicher?

Weder noch. Ich machs so:

if(x) {
  Bla;
  Blabla;
  }
else {
  Blubber;
  Blub;
  }

Ist aber echt Geschmacksache. Mein Bildschirm hat eben nicht so arg 
viele Zeilen, da ist kompakter Code übersichtlicher, weil ich dann nicht 
so viel scrollen muss.

[J.-u. G. (juwe)]

Markus W. schrieb:
> Weder noch. Ich machs so:
> if(x) {
>   Bla;
>   Blabla;
>   }
> then {
>   Blubber;
>   Blub;
>   }

War nicht von C die Rede?

[Ingo (Gast)]

Interessant wie viele Sachen sich unterscheiden. Jemand dabei der das 
Hauptberuflich macht und am Tag zig Zeilen Code schreibt?

[Karol B. (johnpatcher)]

Ein "besser" gibt es hier natürlich nicht. Die Hauptsache ist hier wohl 
eher die Konsequenz, gerade wenn man im Team arbeitet. Das erleichtet 
vor allem das Lesen von "fremden" Quellcode (und darunter verstehe ich 
z.B. auch eingenen Quellcode, der etwas "älter" ist). I.d.R. sind das 
aber Fragen, welche im Rahmen von Code Conventions 
(https://de.wikipedia.org/wiki/Code_Convention) geklärt werden und 
gerade bei größeren Projekten verpflichtend sind.

Sinnvoll kann es unter Umständen sein die Code Conventions von "großen" 
Projekten zu übernehmen. Im Bereich "C" gibt es da unter anderem z.B. 
die GNU Coding Standards 
(https://www.gnu.org/prep/standards/standards.html) oder den Linux 
kernel coding style 
(https://www.kernel.org/doc/Documentation/CodingStyle).

[Markus W. (Firma: guloshop.de) (m-w)]

Ingo schrieb:
> Interessant wie viele Sachen sich unterscheiden. Jemand dabei der das
> Hauptberuflich macht und am Tag zig Zeilen Code schreibt?

Ja, ich - wie vermutlich die anderen auch. Allerdings verwende ich für 
Mikrocontroller viel lieber Assembler.

Ansonsten stimme ich Karol Babioch voll und ganz zu.

[Bernd N. (Gast)]

Suchs dir aus...

http://astyle.sourceforge.net/

aber machs richtig :-)

[Stefanie B. (sbs)]

Karol Babioch schrieb:
> Ein "besser" gibt es hier natürlich nicht. Die Hauptsache ist hier wohl
> eher die Konsequenz, gerade wenn man im Team arbeitet. Das erleichtet
> vor allem das Lesen von "fremden" Quellcode (und darunter verstehe ich
> z.B. auch eingenen Quellcode, der etwas "älter" ist). I.d.R. sind das
> aber Fragen, welche im Rahmen von Code Conventions
> (https://de.wikipedia.org/wiki/Code_Convention) geklärt werden und
> gerade bei größeren Projekten verpflichtend sind.

genau.

Ich arbeite an verschiedenen Projekten, die jeweils einen anderen 
Codingstyle haben. Sobald man den jeweiligen Codingstyle verinnerlicht 
hat, geht das umstellen auch einfacher und schneller.

Wichtig ist vor allem Konsistenz innerhalb eines Projektes.

[Gelöscht (kami89)]

Anfangs habe ich es so gemacht:
> If (x){
>    Bla bla;
> }

In der Schule haben wir es dann so "gelernt":
> If (x)
> {
>    Bla bla;
> }

mittlerweile gefällt mir die zweite Methode viel besser als die erste, 
ich finde es einfach übersichtlicher...

[Johann L. (gjlayde)]

HildeK schrieb:
> Ingo schrieb:
>> If(x)
>> {
>>    Bla bla;
>> }
>
> ist für mich übersichtlicher.

Für mich auch:

Die schliessende Klammer auf der gleichen Ebene wie die öffnende.

Und vor die ( gehört ein Leerzeichen:

if (x)
{
    Bla bla;
}
else if (y)
{
    blubb (x);
}

[Yalu X. (yalu) (Moderator)]

In diesem Fall setze ich überhaupt keine Klammern:

if(x)
  Bla bla;

Außerdem schreibe ich das "if" immer mit einem kleinen 'i', auch am
Zeilenanfang :)

[µMidas (Gast)]

HildeK schrieb:
> Ingo schrieb:
>> If(x)
>> {
>>    Bla bla;
>> }
>
> ist für mich übersichtlicher.

dito.!

[jogitech (Gast)]

if(...)
    {
    x = blabla
    }

Das finde ich am übersichtlichsten, weil alles folgende auf der gleichen 
ebene eingerückt ist.
...hab ich bei python abgeschaut - da geht das ganze ohne klammern.

if(...)
    {
    x = blabla
    while(...)
        {
        blabla
        }
    function()
    }

spricht da etwas dagegen?

[Yalu X. (yalu) (Moderator)]

Wenn die Einrückungen überall richtig gemacht werden, spielt die
Position der Klammern für mich persönlich kaum keine Rolle. Auch so
etwas würde ich nicht anprangern:

if(x>5) {
  a = 0;
  b = 1; }
else {
  a = 2;
  b = 3; }

Immerhin spart man dadurch einige Fast-Leerzeilen, bekommt dadurch mehr
Code auf einer Bildschirmseite zu sehen und hat deswegen einen besseren
Überblick.

Nachteil: Das Einfügen neuer Zeilen am Ende eines Blocks ist etwas
umständlich, weil man dann die letzte Zeile vor der schließenden Klammer
umbrechen muss.

Deswegen ist folgendes ein guter Kompromiss, den ich auch verwende, wenn
nicht gerade irgendwelche Style-Guides etwas anderes vorschreiben:

if(x>5) {
  a = 0;
  b = 1;
}
else {
  a = 2;
  b = 3;
}

[Arc N. (arc)]

Eigentlich wurde schon alles gesagt: Code conventions bei 
größeren/Team-Projekten etc.
Wenn ich's aussuchen darf bzw. intern:
Beispiel 1. das allerdings an allen Stellen (d.h. auch bei struct, 
class, Funktionen etc.) und TAB = 4 Leerzeichen
Wenn die Sprache auch ausgesucht werden darf:

if abc then
   xyz
elif bcd 
   yza 
else
   zab

Ctrl+E, D

[Wiggerl (Gast)]

der Allman-Stil (siehe unten) ist meiner Meinung nach der 
Übersichtlichste.
Ich hab früher auch im K&R-Stil programmiert, fand ich kompakter. Heute 
weiß ich, dass mein Monitor groß genug ist um die Nachteile des 
Allman-Stil zu kompensieren und der Code wirkt damit einfach viel 
ordentlicher, übersichtlicher und aufgeräumter. Vor allem aber erkennt 
man wesentlich besser wo eine Klammer geöffnet und wo sie geschlossen 
wird, wenn der Code größer wird.




http://de.wikipedia.org/wiki/Einr%C3%BCckungsstil#Allman_.2F_BSD_.2F_.E2.80.9EEast_Coast.E2.80.9C

[Yalu X. (yalu) (Moderator)]

Mal etwas avantgardistisch:

if(x>5)                                                                {
  a = 0                                                               ;
  b = 1                                                               ;}
else                                                                   {
  a = 2                                                               ;
  b = 3                                                               ;}
funktion(a, b)                                                        ;

Alle hässlichen Semikola und geschweiften Klammern werden dorthin ver-
bannt, wo sie das Auge kaum noch stören, vom Compiler aber noch gesehen
werden. Wenn man jetzt nur noch die wenig Information enthaltenden run-
den Klammern in der If-Anweisung und dem Funktionasaufruf ins Abseits
stellen könnte, würde der C-Code schon beinahe so edel aussehen wie der
Nicht-C-Code von meinem Vorvorposter ;-)

[Yalu X. (yalu) (Moderator)]

Wiggerl schrieb:
> Heute weiß ich, dass mein Monitor groß genug ist um die Nachteile des
> Allman-Stil zu kompensieren

Vorsicht: Die vertikale Auflösung (vor allem bei Laptopdisplays) ist
derzeit rückläufig. In ein paar Jahren, wenn die Standardauflösung
3840×540 (Superwide Full HD) oder gar 7680×270 (Ultrawide Full HD) sein
wird, wirst du dich wieder an die Vorteile des K&R-Stils erinnern ;-)

[Gelöscht (kami89)]

Yalu X. schrieb:
> Mal etwas avantgardistisch:

Sieht wirklich sehr schön aus, Kann man Eclipse beibringen das 
automatisch so zu machen? :-D

Yalu X. schrieb:
> Vorsicht: Die vertikale Auflösung ist (vor allem bei Laptopdisplays)
> derzeit rückläufig. In ein paar Jahren, wenn die Standardauflösung
> 3840×540 (Superwide Full HD) oder gar 7680×270 (Ultrawide Full HD) sein
> wird, wirst du dich wieder an die Vorteile des K&R-Stils erinnern ;-)

Echt traurig, dass da sogar einen Funken Wahrheit drin steckt...

[Johann L. (gjlayde)]

jogitech schrieb:

> if(...)
>     {
>     x = blabla
>     }
>
> spricht da etwas dagegen?

Es ist sehr unüblich.  Das ist an sich nix schlimmes, erschwert dir aber 
gerne das Lesen von Fremdcode:  Code (bzw. alles was man liest) wird 
eher als Bild wahrgenommen als die Abfolge einzelner Zeichen.

Wie leicht man einen Text liest, wird daher auch dadurch bestimmt, wie 
vertraut ein bestimmer Testsatz bz. Coding-Rule ist.  Unübliche 
Coding-Rules erschweren also das Lesen von Code — sowohl wenn du anderen 
Code liest, als auch wenn andere deinen Code lesen.

Ausserdem ist es schwer, sich solche hausbackenen Stile wieder 
abzugewöhnen. Das weiß ich aus eigener Erfahrung ;-)

Die Klammer hinten ans Zeilenende des if zu schreiben oder mit dem Code 
einzurücken hat aber auch handfeste Nachteile in ausgewachsenen 
Projekten mit komplexen Klauseln.

Ein Beispiel für so ein Projekt, in den lange Klauseln keine Seltenheit 
sind, ist GCC.  Hier zwei Beispiele aus avr-gcc, bei denen das 
Verhältnisse zwischen Codegröße in der Klausen und Codegröße im Block 
genau umgekehrt sind wie gewohnt:

Beispiel 1
 

  if (EQ != GET_CODE (XEXP (ifelse1, 0))
      || !REG_P (XEXP (comp1, 0))
      || !CONST_INT_P (XEXP (comp1, 1))
      || XEXP (ifelse1, 2) != pc_rtx
      || XEXP (ifelse2, 2) != pc_rtx
      || LABEL_REF != GET_CODE (XEXP (ifelse1, 1))
      || LABEL_REF != GET_CODE (XEXP (ifelse2, 1))
      || !COMPARISON_P (XEXP (ifelse2, 0))
      || cc0_rtx != XEXP (XEXP (ifelse1, 0), 0)
      || cc0_rtx != XEXP (XEXP (ifelse2, 0), 0)
      || const0_rtx != XEXP (XEXP (ifelse1, 0), 1)
      || const0_rtx != XEXP (XEXP (ifelse2, 0), 1))
    {
      return false;
    }

Beispiel 2
 

  /* Ensure that caller and callee have compatible epilogues.  */
  
  if (cfun->machine->is_interrupt
      || cfun->machine->is_signal
      || cfun->machine->is_naked
      || avr_naked_function_p (decl_callee)
      /* FIXME: For OS_task and OS_main, we are over-conservative.
         This is due to missing documentation of these attributes
         and what they actually should do and should not do.  */
      || (avr_OS_task_function_p (decl_callee)
          != cfun->machine->is_OS_task)
      || (avr_OS_main_function_p (decl_callee)
          != cfun->machine->is_OS_main))
    {
      return false;
    }
 
  return true;

Hier sind Einrückungen, Zeilenumbrüche und Leerzeichen übrigens gemäß 
den für GCC verbindlichen GNU-Rules.

[jogitech (Gast)]

... Dann eben senkrecht in alt-chinesisch schreiben, dann klappt es auch 
wieder mit der auflösung (-;

[jogitech (Gast)]

@johann;

stimmt, das ist in meiner Formatierung schlecht lesbar,
Vermutlich gibt es wirklich kein patentrezept.

Es ist wohl am besten mann gewöhnt sich an eine weit verbreitete 
Schreibbweise.

[Verwirrter Anfänger (Gast)]

Yalu X. schrieb:
> In diesem Fall setze ich überhaupt keine Klammern:
> if(x)
>   Bla bla;
>

Nur als Anmerkung:
Bei uns kriegt man da ganz schnell einen auf die Finger gehauen. Das 
kann spät abends zu dämlichen Fehlern führen:

Aus

if (type != 0x01)
  flag |= TYPE_ERROR;

if (value > 127)
  flag |= VALUE_ERROR;

wird morgens um 3 beim debuggen gerne mal:

if (type != 0x01)
  printf("\n\rType Error!");
  flag |= TYPE_ERROR;

if (value > 127)
  flag |= VALUE_ERROR;
  printf("\n\rValue Error!");

Nachdem mir das nur einmal passiert ist (ich glaub sogar in Java oder 
PHP), setzt ich inzwischen mit vollster Hingabe Klammern hinter alle 
Bedingungen.

[Arc N. (arc)]

Yalu X. schrieb:
> Mal etwas avantgardistisch:

Sehr schön

> Alle hässlichen Semikola und geschweiften Klammern werden dorthin ver-
> bannt, wo sie das Auge kaum noch stören, vom Compiler aber noch gesehen
> werden. Wenn man jetzt nur noch die wenig Information enthaltenden run-
> den Klammern in der If-Anweisung und dem Funktionasaufruf ins Abseits
> stellen könnte, würde der C-Code schon beinahe so edel aussehen wie der
> Nicht-C-Code von meinem Vorvorposter ;-)

F#, ML, Haskell

Wenn nur die Semikola stören, aber geschweifte Klammern vorkommen 
sollen: Go
Sollen zumindest die runden Klammern beim if erhalten bleiben: Scala, 
wer mehr Klammern braucht -> http://xkcd.com/297/

Urban B. schrieb:
> Sieht wirklich sehr schön aus, Kann man Eclipse beibringen das
> automatisch so zu machen? :-D

Zumindest NetBeans kann man unter Fonts&Colors beibringen die 
"überflüssigen" Trennzeichen weiß auf weiß darzustellen, dann sind alle 
({,;}) weg ;-)

[Yalu X. (yalu) (Moderator)]

Verwirrter Anfänger schrieb:
>> if(x)
>>   Bla bla;
>>
>
> Nur als Anmerkung:
> Bei uns kriegt man da ganz schnell einen auf die Finger gehauen. Das
> kann spät abends zu dämlichen Fehlern führen:

Ich weiß. In einigen Programmierichtlinien sind deswegen die
geschweiften Klammern auch für Einzelanweisungen explizit
vorgeschrieben.

Noch besser ist es aber, spätabends gar nicht mehr zu programmieren,
sondern allenfalls in mikrocontroller.net darüber zu diskutieren ;-)



@alle Klammerhasser:

Es gibt da tatsächlich ein paar Verrückte, die C seiner geschweiften
Klammern und Semikola beraubt und stattdessen eine Python-ähnliche
Blocksyntax aufgesetzt haben:

  http://blog.brush.co.nz/2007/09/nobraces/
  http://code.google.com/p/pythoidc/

Natürlich gibt es das Ganze auch andersherum für Leute, die die
erzwungene Einrückung in Python hassen und stattdessen lieber ein paar
Klammern schreiben:

  http://timhatch.com/projects/pybraces/

[Verwirrter Anfänger (Gast)]

Yalu X. schrieb:
> Noch besser ist es aber, spätabends gar nicht mehr zu programmieren,
> sondern allenfalls in mikrocontroller.net darüber zu diskutieren ;-)

Nachdem ich endlich nach 3 Stunden den I2C auf meinen Discovery Board 
zum laufen gekriegt habe, kann ich dem nur zustimmen.
(Es lag alles nur an einem fehlenden NACK...)

[Fachkraft (Gast)]

Yalu X. (yalu) (Moderator)

Wiggerl schrieb:
>> Heute weiß ich, dass mein Monitor groß genug ist um die Nachteile des
>> Allman-Stil zu kompensieren

> Vorsicht: Die vertikale Auflösung (vor allem bei Laptopdisplays) ist
> derzeit rückläufig. In ein paar Jahren, wenn die Standardauflösung
> 3840×540 (Superwide Full HD) oder gar 7680×270 (Ultrawide Full HD) sein
> wird, wirst du dich wieder an die Vorteile des K&R-Stils erinnern ;-)

Ach was. Dann dreht mal den Lappi um 90° rum und hat Zeilen bis zum 
Abwinken. Da passt der gesamte Sourcecode von Sprint-Layout auf einen 
Screen.

:-)

[Yalu X. (yalu) (Moderator)]

Arc Net schrieb:
> F#, ML, Haskell

Das Schöne bei diesen Sprachen ist, dass man zwischen beiden Modi
aussuchen kann:

- Einrückungen syntaktisch relevant:
  -> einfachere Syntax
  -> mehr Übversichtlichkeit

- Einrückungen nicht relevant, Strukturierung erfolgt durch zusätzliche
  Schlüsselwörter und/oder Sonderzeichen:
  -> praktisch im interaktiven Modus und bei automatischer Code-
     Generierung
  -> die Tabulatorfritzen fallen nicht ständig auf die Nase ;-)


> Wenn nur die Semikola stören, aber geschweifte Klammern vorkommen
> sollen: Go
> Sollen zumindest die runden Klammern beim if erhalten bleiben: Scala,
> wer mehr Klammern braucht -> http://xkcd.com/297/

Eins hast du noch vergessen:

Wen alle Klammern, alle Satzzeichen, alle Operatorzeichen, alle
Buchstaben und alle Ziffern stören, der nehme Whitespace:

  http://de.wikipedia.org/wiki/Whitespace_%28Programmiersprache%29

;-)

[M. K. (avr-frickler)]

Ich schreibe auch gerne etwas kompakter also Variante 1.

Wie haltet ihr es bei switch-case Blöcken?

switch(x) {
case 1:
    blah();
    break;
case 2:
    blah();
    break;
case 3:
    blah();
    break;
}

So schaut es bei mir aus. Ich mag es halt nicht wenn der Code so breit 
wird, dass man ständig den horizontalen Scrollbalken des Editors 
verwenden muss.

[Peter D. (peda)]

M. K. schrieb:
> Wie haltet ihr es bei switch-case Blöcken?

Da rücke ich 2-mal ein, einmal die Case und dann den Code.
D.h. unter dem 's'(witch) steht nur die schließende '}' und ich erkenne 
sofort das Ende.

Auch gönne ich mir eine Leerzeile vor jedem Case. Da sieht man besser, 
welche Case es gibt, bzw. ob einer fehlt.


Peter

[Peter D. (peda)]

Leerzeichen setze ich anders.
Die Schlüsselwörter kennt man ja, die braucht man nicht extra 
abzusetzen, das macht außerdem schon das Syntax-Highlighting.

Dagegen setze ich die Ausdrücke ab, denn auf die kommt es ja an. Die 
sollten also hervortreten und leicht lesbar sein:

  if(    Ausdruck1
      && Ausdruck2 ){
    blabla;
  }else{
    blubblub;
  }

Peter

[Mikel M. (mikelm)]

Also ich bevorzuge auch eindeutig oben nr 2 , die Blockübersicht bleibt 
erhalten. für mich ist übersichtlichkeit wichtig.

switch(x) 
{
  case 1:
    blah();
  break;
  case 2:
    blah();
  break;
  case 3:
    blah();
  break;
}

aber case ist etwas besonderes der sieht auch schon mal so aus

switch(x) 
{
  case  1:  blah(x+7);                 y= 0;  break;
  case  2:  blah(x/6);    bla2(14+x);  y= 2;  break;
  case  3:  blah(y+8888); bla2(122);   y=-2;  break;
    ...
  case 23:  blah(x);      bla2(3);     y= 7;  break;
  default: err....
}

 sprich alles steht schon senkrecht untereinander, so das man die 
Unterschiede schön schnell erfassen kann. gibt aber nur für die Stellen
 die so aufgebaut sind. sprich passen in eine Zeile unterscheiden sich 
durch Feinheiten. ansonsten würde so ein switch über Seiten gehen.
 Auch gibts bei mir oft Einzeiler

 if ( x > 12 ) x=12; else if ( x <  0) x= 0;  // check überlauf x
 if ( y > 22 ) x=22; else if ( y <= 0) y=-1;  // check überlauf y

 Wenn man den Code lesen will, beschäftigt man sich einmal mit der 
Zeile, danach kann man sie mit dem Kommentar schnell erfassen. um den 
Ablauf zu erfassen ist es dann viel einfacher, weil man den zu 
verstehenene Block ohne zu scrollen lesen kann, sonst wären die beiden 
if ja schon nem netbook schon fast eine ganze Seite code. Anfänger sind 
mit solchen Zeilen vielleicht überfordert, aber ich kann sie problemlos 
mit einem Blick erfassen. Jeder erfahrene Programmierer sollte so eine 
Zeile problemlos erfassen und den Sinn verstehen können ohne ernsthaft 
dadrüber nachdenken zu müssen was sie macht.
  Darum mag ich auch z.b. keine Sprachen die mir eine Formatierung 
aufzwingen wollen und für jede Kleinigkeit eine eigene Zeile haben 
wollen. (Assembler sehe ich nicht als Sprache, darum fällt es auch nicht 
unter dieser Aussage, das ist etwas für sich.)

[Ingo L. (Gast)]

Interessant wie fast jeder hier anders arbeitet...



Ingo

[Marwin (Gast)]

Vieleicht wuerde es einigen helfen, sich mal mit den C-Grundlagen zu 
beschaeftigen. Dann wuessten sie, dass die Klammen zum Block gehoeren 
und nicht zum if, else, while oder sonstwas. Und was logisch zusammen 
gehoert, sollte auch optisch zusammen stehen. Also kommt die oeffnende 
Klammer an den Anfang des Blocks und nicht an's Ende vom if, else, 
while, etc...

[Arc N. (arc)]

Marwin schrieb:
> Vieleicht wuerde es einigen helfen, sich mal mit den C-Grundlagen zu
> beschaeftigen. Dann wuessten sie, dass die Klammen zum Block gehoeren
> und nicht zum if, else, while oder sonstwas. Und was logisch zusammen
> gehoert, sollte auch optisch zusammen stehen. Also kommt die oeffnende
> Klammer an den Anfang des Blocks und nicht an's Ende vom if, else,
> while, etc...

"First off, I'd suggest printing out a copy of the GNU coding standards,
and NOT read it.  Burn them, it's a great symbolic gesture." scnr
http://www.kernel.org/doc/Documentation/CodingStyle
K&R, Stroustrup http://www.stroustrup.com/bs_faq2.html

[Yalu X. (yalu) (Moderator)]

Marwin schrieb:
> Also kommt die oeffnende Klammer an den Anfang des Blocks und nicht
> an's Ende vom if, else, while, etc...

Also so:

if(x>5)
{a = 0;
 b = 1;}
else
{a = 2;
 b = 3;}

So sind die Klammern maximal dicht am Anfang und am Ende des jeweiligen
Blocks ;-)

[Random .. (thorstendb)]

So:

void Func(int foo)
{
  int x;

  if(foo) {
    switch(foo) {
      case A:
        x = 7;
        break;

      case B: {
        x = 42;
        Func2(x);
      } break;
    }
  }
  else {
    foo = 2;
  }

  if(x) {
    foo = 1;
  } else {
    foo = 2:
  }

  do {
   x++;
  } while(foo--);
}

[Peter D. (peda)]

Marwin schrieb:
> Und was logisch zusammen
> gehoert, sollte auch optisch zusammen stehen.

Genauso sehe ich das auch. Alles in den Klammern wird bedingt 
ausgeführt, gehört also zum if, while usw.. Daher ist es für mich 
vollkommen logisch, daß es auch direkt hinter dem if() beginnt.


Peter

[Random .. (thorstendb)]

Dazu kommen dann einige Variationen, z.B:

if(foo<7) x=2; else x = 1;

oder die zweite case/break Variante von Mikel.

[Alexander V. (avogra)]

Also speziell bei switch hab ich mir folgendes angewöhnt:

switch (x) {
  case (1): {
    blah();
  }break;

  case (2): {
    blubb();
  }//fallthrough

  default: {
    boing();
  }
}

die extra Klammern sind sicher nicht notwendig, ich finds aber 
konsistenter mit anderen Konstrukten und die anweisungsblöche werden 
schön von case und break umrahmt.

[M. K. (avr-frickler)]

Random ... schrieb:
> if(foo<7) x=2; else x = 1;

x = foo < 7 ? 2 : 1;

[Ingo L. (Gast)]

Alexander v. Grafenstein schrieb:
> switch (x) {
>   case (1): {
>     blah();
>   }break;
>
>   case (2): {
>     blubb();
>   }//fallthrough
>
>   default: {
>     boing();
>   }
> }

Beim case (1) kommt das break aber vor die Klammer :)

M. K. schrieb:
> x = foo < 7 ? 2 : 1;
Ja, sowas kann dann auch jeder nachvollziehen. Sowas schreibt glaube ich 
kaum einer.


Ingo

[Random .. (thorstendb)]

Ingo L. schrieb:
> M. K. schrieb:
>> x = foo < 7 ? 2 : 1;
> Ja, sowas kann dann auch jeder nachvollziehen. Sowas schreibt glaube ich
> kaum einer.

Doch, eig. schon :-)

foo = x? 1 : 2;

#define NOZERO(x)      (x? x : 1)

led_out(1<<(ledCnt = ++ledCnt<8 ? ledCnt : 0));  // feed the running light

@M.K.:
Das war nur ein Beispiel :-)

[lowlevel (Gast)]

Ingo L. schrieb:
> M. K. schrieb:
>> x = foo < 7 ? 2 : 1;
> Ja, sowas kann dann auch jeder nachvollziehen. Sowas schreibt glaube ich
> kaum einer.

Naja, wenn man sich mal dran gewöhnt hat finde ich die Schreibweise für 
einfache Bedingungen ganz sinnvoll.

[Mikel M. (mikelm)]

M. K. schrieb:
> Random ... schrieb:
>> if(foo<7) x=2; else x = 1;
>
>

x = foo < 7 ? 2 : 1;

Ich würde bei soetwas klammern, es erhöht die Lesbarkeit.

>

x = (foo < 7) ? 2 : 1;

[Alexander V. (avogra)]

Ingo L. schrieb:
> Alexander v. Grafenstein schrieb:
>> switch (x) {
>>   case (1): {
>>     blah();
>>   }break;
>>
>>   ...
>> }
>
> Beim case (1) kommt das break aber vor die Klammer :)

Hatte ich zuerst, aber so gefällts mir besser. vgl. z.B. auch do{ 
}while;

[Michael S. (rbs_phoenix)]

Also ich schreib immer so:

if(x == true){
  //Code
  //bla bla bla
}

else{
  //anderer Code
}

if(x == true) einzeiler();
else anderer_einzeiler();

An der schließenden Klammer nach oben gepeilt findet man immer das 
dazugehörige if (oder else oder switch usw.).

Alles zusammengerückt, allerdings in der Bedingung dann ein Leerzeichen, 
wo es hinkommt (x == true).

[Mikel M. (mikelm)]

Michael Skropski schrieb:

>
> An der schließenden Klammer nach oben gepeilt findet man immer das
> dazugehörige if (oder else oder switch usw.).

 Du findest zwar das if, aber ob das dazugehört entscheidet die öffnende 
Klammer, darum gehören bei mir das "i", "{" und "}" auf eine Line um 
auch beim Ausdruck ganz problemlos die Verschachtelung überprüfen zu 
können, da alles auf einer Geraden ist. Man muß für die Verschachtelung 
einfach nur den linken Rand senkrecht verfolgen.

[Markus W. (Firma: guloshop.de) (m-w)]

Mikel M. schrieb:
> Ich würde bei soetwas klammern, es erhöht die Lesbarkeit.
>

x = (foo < 7) ? 2 : 1;

Ich schreibs so:

x= foo<7? 2: 1;

Jeder halt wie er mag. :-)

[trollalala (Gast)]

Markus W. schrieb:
> Ich schreibs so:
und ich so

x=(foo<7)+1

SCNR

[blabb (Gast)]

Ich verwende eine richtige Programmiersprache, wodurch die Verwendung 
des "{"/"}"-Gefrickels überflüssig ist und sich die Frage 
dementsprechend nicht stellt!

[Michael L. (michaelx)]

Das grenzt ja schon an religiöses Geseier ...

Geschweifte Klammern gehören immer auf eine eigene Zeile!

Warum das nur genau so richtig ist, werdet ihr merken wenn ihr
1. mal mit einer Versionsverwaltung gearbeitet habt.
2. bedingte Compilierung in nicht unerheblichem Umfang braucht.

Denn dann fliegt euch solcher Geiz-ist-geil-Code um die Ohren:

If (x){
   Bla bla;}

Grüße.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Michael L. schrieb:
> Denn dann fliegt euch solcher Geiz-ist-geil-Code um die Ohren:If (x){
>    Bla bla;}

Wenn Du schon damit Probleme hast ...

[Michael L. (michaelx)]

Joachim Drechsel schrieb:
> Wenn Du schon damit Probleme hast ...

Wo habe ich das geschrieben? Aber starte ruhig so eine Nebelkerze.
Lenkt ja prima davon ab, dass du nichts verstanden hast.

SCNR

[Christian H. (christian_h)]

Definitiv Nummer 1, weil ich unnötige Zeilen nicht mag, ich finde das 
einfach so übersichtlicher.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Michael L. schrieb:
> Joachim Drechsel schrieb:
>> Wenn Du schon damit Probleme hast ...
>
> Wo habe ich das geschrieben? Aber starte ruhig so eine Nebelkerze.
> Lenkt ja prima davon ab, dass du nichts verstanden hast.
>
> SCNR

Was ein Unsinn ...

[Klammeraffe (Gast)]

Pfeif auf C/C++/Java!

Es lebe Brainf.u.c.k:
http://de.wikipedia.org/wiki/Brainf.u.c.k
(letzten 3 Punkte im Link entfernen, musste sein, da Beitrag sonst als 
"SPAM" abgelehnt wurde.

Was waren das noch für Zeiten, als nicht jeder Spacko am Rechner 
rumfummeln durfte ...

P.S. Überarbeitet mal eure Forensoftware. Brainf.u.c.k. ist einer 
ordentliche Programmiersprache.
Dummsuff beim Absenden: "Der Beitrag scheint Spam zu enthalten: 
"f.u.c.k"

[Yalu X. (yalu) (Moderator)]

Michael L. schrieb:
> Warum das nur genau so richtig ist, werdet ihr merken wenn ihr
> 1. mal mit einer Versionsverwaltung gearbeitet habt.

Wie kommst du darauf?

Bei mir hat sich die Versionsverwaltung noch nie über die Klammersetzung
beschwert, egal nach welchem Style-Guide ich programmiert habe. Selbst
Nicht-C-Programme, die überhaupt keine geschweiften Klammern verwenden
oder wo diese eine ganz andere Bedeutung haben, verdaut sie problemlos.

[docean (Gast)]

Yalu X. schrieb:
> Wie kommst du darauf?

https://de.wikipedia.org/wiki/Einr%C3%BCckungsstil#Horstmann

@Topic
Ich schreibe wie ich will und lass dann einmal VS das ganze formatieren 
;)

[Christian H. (christian_h)]

Klammeraffe schrieb:
> Pfeif auf C/C++/Java!
>
> Es lebe Brainf.u.c.k:
> http://de.wikipedia.org/wiki/Brainf.u.c.k
> (letzten 3 Punkte im Link entfernen, musste sein, da Beitrag sonst als
> "SPAM" abgelehnt wurde.
>
> Was waren das noch für Zeiten, als nicht jeder Spacko am Rechner
> rumfummeln durfte ...
>
> P.S. Überarbeitet mal eure Forensoftware. Brainf.u.c.k. ist einer
> ordentliche Programmiersprache.
> Dummsuff beim Absenden: "Der Beitrag scheint Spam zu enthalten:
> "f.u.c.k"

Wie alt bist du? 10?  Was bedeutet, was waren das für Zeiten? Brainf*** 
ist niemals eine urzeitliche Sprache gewesen, in der in älteren Tagen 
programmiert wurde. Da wären eher Maschinensprache, FORTRAN, BASIC und C 
(gibt noch andere Kandidaten, aber sicher nicht Brainf***).
Deine Aussage macht dich eher lächerlich.

[Michael L. (michaelx)]

Yalu X. schrieb:
> Michael L. schrieb:
>> Warum das nur genau so richtig ist, werdet ihr merken wenn ihr
>> 1. mal mit einer Versionsverwaltung gearbeitet habt.
>
> Wie kommst du darauf?
>
> Bei mir hat sich die Versionsverwaltung noch nie über die Klammersetzung
> beschwert, egal nach welchem Style-Guide ich programmiert habe. Selbst
> Nicht-C-Programme, die überhaupt keine geschweiften Klammern verwenden
> oder wo diese eine ganz andere Bedeutung haben, verdaut sie problemlos.

Nun ja, der Versionsverwaltung ist die Klammersetzung auch pupsegal.

Aber wenn du ein diff machst, dann werden die Unterschiede sehr schnell 
unübersichtlich, wenn, was gar nicht so selten der Fall ist, am Anfang 
oder Ende eines geklammerten Code-Blocks noch ein Statement eingefügt 
werden muss. Dann bekommst du statt einer simplen zusätzlichen Zeile 
eine Ersetzung einer Zeile auf der einen Seiter durch 2 Zeilen auf der 
anderen angezeigt. OK, bei 5-10 Zeichen pro Zeile wie im Beispiel ist 
das nicht sooo dramatisch. Aber wer mal einen umfangreicheren 
Code-Review/QS mit etwas mehr als 100 Codezeilen (also eher ab 10^6 bis 
10^7 Zeilen) machen darf/muss, wird es möglicherweise besser verstehen.

Mal abgesehen davon ist die Erkenntnis auch nicht von mir (-> Literatur, 
wurde auh schon verlinkt). Aber sie hat sich schon oft bestätigt.

Grüße.

[Yalu X. (yalu) (Moderator)]

docean schrieb:
>> Wie kommst du darauf?
>
> https://de.wikipedia.org/wiki/Einr%C3%BCckungsstil#Horstmann

Michael L. schrieb:
> Aber wenn du ein diff machst, dann werden die Unterschiede sehr schnell
> unübersichtlich, wenn, was gar nicht so selten der Fall ist, am Anfang
> oder Ende eines geklammerten Code-Blocks noch ein Statement eingefügt
> werden muss.

Ok, das ist ein Argument. Wobei ein vernünftiges Diff-/Merge-Tool ja
nicht nur geänderte Zeilen anzeigt, sondern auch die Unterschiede
innerhalb von Zeilen. Damit wird sofort deutlich, dass sich die eine
Zeile nur deswegen geändert hat, weil die geschweifte Klammer in die
neu eingefügte Zeile gerutscht ist. Es kann also nicht die Rede davon
sein, dass einem der "Geiz-ist-geil-Code um die Ohren fliegt".

Es ist diesbezüglich auch nicht unbedingt erforderlich, jede geschweifte
Klammer in eine eigene Zeile zu schreiben. Sie sollte nur nicht zusammen
mit einer Anweisung des Blocks, die sie umschließt, in einer Zeile
stehen.

So etwas ist also nicht so toll (so machen's auch die wenigsten):

if(x > 5)
{ a = 0;     // <- nicht so toll
  b = 1; }   // <- dto.
else
{ a = 2;     // <- dto.
  b = 3; }   // <- dto.

Folgendes ist aber "VCS-fest", da nach Belieben neue Codezeilen
eingefügt werden können, ohne die Klammern zu verschieben:

if(x > 5) {
  a = 0;
  b = 1;
} else {
  a = 2;
  b = 3;
}

[Johann L. (gjlayde)]

Michael L. schrieb:
> Yalu X. schrieb:
>> Michael L. schrieb:
>>> Warum das nur genau so richtig ist, werdet ihr merken wenn ihr
>>> 1. mal mit einer Versionsverwaltung gearbeitet habt.
>>
>> [...]
>>
>
> Nun ja, der Versionsverwaltung ist die Klammersetzung auch pupsegal.

Zitat Onkel Wiki:

>> Für VCS-Tools ist dieser Stil problematisch. Fügt man ein neues
>> Statement zwischen dem "{" und dem ersten Statement ein, erscheint
>> diese Änderung als "eine Zeile wird durch 2 Zeilen ersetzt" statt
>> "eine neue Zeile wurde eingefügt". Das heißt, die ursprüngliche Zeile
>> wird als "geändert" markiert, obwohl sie semantisch gleich geblieben ist.

[interrupt (Gast)]

Immer zwei Leerzeichen eingerückt, Klammern untereinander :

If(x)
  {
    Bla bla;

    while ()
      {
        bla bla
      }
  }

[Micha (Gast)]

Ich mache das meistens so:

if(a==b)
{
    foo1();
    foo2();
}
else
{
    foo1();
}

oder so:

for(int i=0; i<10; i++)
{
    foo1();
}

bei nur einer Zeile

[code]
if(a==b)
    foo1();
else
    foo1();

[Michael S. (rbs_phoenix)]

Mikel M. schrieb:
> Du findest zwar das if, aber ob das dazugehört entscheidet die öffnende
> Klammer

int main(){
  if(...){
    while(...){
      if(...){
        //...
      }
    }
  }
  else{
    switch(...){
      case 1:
        //bla bla bla
        break;
      case default:
        //bla
        break;
    }
  }
}

Es ist aber für mich egal, ob ich weiß, dass hinter der Bedingung eine 
"{" ist oder dass ich sehe, das darunter eine "{" ist. Zu jeder if 
(usw.) gehört eine geschwungene Klammer, also muss diese Klammer nicht 
dadrunter sein, weil ich weiß, dass es sie gibt. Da wo man sie weglassen 
kann schreib ich den Rest in die gleiche Zeile. Aber jeder macht es halt 
so wie er will.

[Marwin (Gast)]

Ich frage mich, ob ihr Buecher lesen wuerdet, die die Autoren nach euren 
Regeln geschrieben haben. Keine Absaetze, keine Leerzeilen, ohne Punkt 
und Komma. Und moeglichst viele Abkuerzungen. Hauptsache, viel Text auf 
einer Seite.

[Yalu X. (yalu) (Moderator)]

Marwin schrieb:
> Ich frage mich, ob ihr Buecher lesen wuerdet, die die Autoren nach euren
> Regeln geschrieben haben.

Wahrscheinlich nicht, weil sie so viel Whitespace enthielten, dass ein
200-seitigen Taschenbuch schnell zu einem 5-bändigen Werk mit 800 Seiten
pro Band explodieren würde. Das wäre mir einfach zu teuer.

> Keine Absaetze, keine Leerzeilen, ohne Punkt und Komma.

Wo vermisst du in den bisher geposteten (ernstgemeinten) Vorschlägen
diese Elemente? Wobei man ein 6-zeiliges Beispiel nicht unbedingt mit
der gleichen Anzahl an Leerzeilen spicken muss. Bei größeren Programmen
herrscht aber sicher Einigkeit darüber, dass man hier und da eine
Leerzeile zur Gruppierung der einzelnen Codeabschnitte einfügt.

Übrigens: Romane enthalten i.Allg. keine Leerzeilen zwischen den
Absätzen. Es geht also durchaus auch ohne ;-)

> Und moeglichst viele Abkuerzungen. Hauptsache, viel Text auf einer
> Seite.

Eben möglichst viel, so dass aber die Übersicht gerade noch erhalten
bleibt. Anders machen es die Buchautoren auch nicht.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Yalu X. schrieb:
> Anders machen es die Buchautoren auch nicht.

Kommt drauf an. Wenn sie nach Seiten bezahlt werden ...

[Michael L. (michaelx)]

Johann L. schrieb:
> Michael L. schrieb:
>> Yalu X. schrieb:
>>> Michael L. schrieb:
>>>> Warum das nur genau so richtig ist, werdet ihr merken wenn ihr
>>>> 1. mal mit einer Versionsverwaltung gearbeitet habt.
>>>
>>> [...]
>>>
>>
>> Nun ja, der Versionsverwaltung ist die Klammersetzung auch pupsegal.
>
> Zitat Onkel Wiki:
>
>>> Für VCS-Tools ist dieser Stil problematisch. Fügt man ein neues
>>> Statement zwischen dem "{" und dem ersten Statement ein, erscheint
>>> diese Änderung als "eine Zeile wird durch 2 Zeilen ersetzt" statt
>>> "eine neue Zeile wurde eingefügt". Das heißt, die ursprüngliche Zeile
>>> wird als "geändert" markiert, obwohl sie semantisch gleich geblieben ist.

Ich möchte dich bitten, in Zukunft mal Beiträge zu Ende zu lesen, und 
Zitate nicht aus dem Zusammenhang zu reißen. Danke!

Auf die Problematik hatte ich schon hingewiesen. Trotz dem ist das 
Wiki-Zitat insofern falsch, weil letztendlich das Problem beim User 
landet. Die Versionsverwaltung zeigt nur das, was sie sieht ...

Grüße.

[Michael L. (michaelx)]

Yalu X. schrieb:
> Michael L. schrieb:
>> Aber wenn du ein diff machst, dann werden die Unterschiede sehr schnell
>> unübersichtlich, wenn, was gar nicht so selten der Fall ist, am Anfang
>> oder Ende eines geklammerten Code-Blocks noch ein Statement eingefügt
>> werden muss.
>
> Ok, das ist ein Argument. Wobei ein vernünftiges Diff-/Merge-Tool ja
> nicht nur geänderte Zeilen anzeigt, sondern auch die Unterschiede
> innerhalb von Zeilen.

Ich verwende auch nur solche Tools, die das können. Aber trotz allem 
leidet die Übersichtlichkeit eben ganz erheblich.

Grüße.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Ingo schrieb:
> Welche Schreibweise gestaltet sich bei viel Code eurer Meinung
> übersichtlicher?
Die erste. Weil ich zwischenzeitlich zwar unglaublich brrrreeeeiiite 
Monitore bekomme, aber leider mit nur sehr geringer Bildschimhöhe.

Und eine Funktion, die nicht auf 1 Bildschirmseite passt, ist schon per 
Definition unübersichtlich, weil nicht überschaubar...

[Ingo (Gast)]

@Lothar
Hehe, das macht Sinn? Heißt das, wenn du in 5 Jahren einen noch 
flacheren Monitor bekommst, dass du automatisch deine Funktionen 
aufräumst :) ?

Ich habe auch ein kleines Projekt geschrieben, etwa 2k Code und muss 
sagen dass ich mich mit  Variante1 durchaus anfreunden konnte. Sonst 
habe ich immer Version2 genommen, das macht aber schnell viel Platz weg.


Ingo

[W.S. (Gast)]

Für mich ist es so am besten lesbar:

if (x)
 { Bla_bla;
   La_la;
   Tralala;
 }

Es ist sparsam genug, auch für Breit-LCD's.
Obendrein kann man durch die gleiche Einrückung der Klammern sehen, wo 
der Block beginnt und endet. Zwei Leerzeichen reichen, ein Tab wäre 
zuviel. Manche Editoren knallen einem ungefragt bei jedem Indent einen 
Tab rein und wehe, wenn man solche Quellen dann mal woandes öffnen 
will..

So richtig zur Hochform kommt die obige Schreibweise aber erst dann, 
wenn man Quellen hat, wo jemand einem einen richtigen Haufen 
geschachtelter Blöcke unterschiedlichster Machart hinterlassen hat und 
dabei eine Klammer irgendwo vergessen hat. Sowas merkt der Compiler bei 
C erst 1000 Zeilen weiter hinten und man darf sich dann halt totsuchen, 
wenn man die öffnende nicht eisern in die gleiche Spalte gesetzt hat wie 
die schließende Klammer.

btw: Das ist eine der Annehmlichkeiten bei Pascal: dort merkt der 
Compiler in den allermeisten Fällen sofort einen Fehler und nicht erst 
1000 Zeilen später.


Ach ja, vor Jahren gab's ja mal Wettbewerbe, wer den übelsten C-Code 
schreibt.

W.S.

[Johann L. (gjlayde)]

Yalu X. schrieb:
> Marwin schrieb:
>> Ich frage mich, ob ihr Buecher lesen wuerdet, die die Autoren nach euren
>> Regeln geschrieben haben.
>
> Wahrscheinlich nicht, weil sie so viel Whitespace enthielten, dass ein
> 200-seitigen Taschenbuch schnell zu einem 5-bändigen Werk mit 800 Seiten
> pro Band explodieren würde. Das wäre mir einfach zu teuer.

Ich find wie Marwin auch — unabhängig vom Code-Stil — dass die meisten 
Beispiele ziemlich quetschig wirken: Möglicht viel Code auf kleinem 
Raum, zumindest die starke Tendenz dazu.

Text-Layout (und zu Text gehört auch Quelltext) sollte sich auch nach 
typographischen Grundregeln richten.

Code aneinanderzuklatschen und mit Leerzeilen zu geizen hilft der 
leserlichkeit nicht.  Den Überblick über den Text bekommt man dich eine 
klare Strukturieren zusammen mit aussagekräftigen Kommentaren.

Möglichst viel auf eine Seite zu bekommen ist m.M. bringt m.M. kein 
Gewinn an Übersichtlichkeit.

Als ich mit avr-gcc anfing hab ich mit zum Beispiel den Code von anderen 
Backends angeschaut.

Alle Backends folgen dem gleichen Code-Stil; dennoch war ich sehr 
übberrascht, wie unterschiedlich Lesbarkeit und Verständlichkeit 
unterschiedlichen Backends ist.  Bei meinen Beiträgen versuche ich nun 
auch, ähnlich angenehm lesbaren Code zu erstellen.

Für eine Datei (avr.c) hab ich mal eine kleine Statistik gemacht:

Zeilen insgesamt                   : 10869
Leerzeilen (auch in Kommentaren)   :  1918
Kommentare (ohne Leerzeilen)       :   666
Zeilen, die nur { enthalten        :   639
Zeilen, die nur } enthalten, incl. :   642
              };  und } /* ... */

Der Code besteht also zu 30% aus Leerzeilen und Zeilen, die nur "{" oder 
"}" enthalten.

Werden auch Kommentare zu diesem "nutzlosem" Code gezählt, erhöht sich 
dessen Anteil an den Quellzeilen auf 36%.

Neben der Formatierung des Codes spielt aber auch das 
Syntax-Highlighting eine entscheidende Rolle für ein Ermüdungsarmes 
Arbeiten mit dem Text.

Eine Hilit-Einstellung, die alle paar Schlüsselworte zu einem anderen 
Schriftschnitt wechselt, lässt den Text schlimm die Bild-Zeitung 
aussehen.

Ein dezentes Einfärben des Codes zusammen mit gutem Textlayout ist 
vollkommen ausreichend, wenn man einen Zeichensatz wählt, der gut 
unterscheidbare Zeichen hat, d.h. Il1| usw. sind leicht und ohne 
Verwechslungsgefahr zu unterscheiden, ditto für  0 und O und ähnliche 
Fälle.

Last not least der Editor selbst: Ein Editor, der einen bestimmten 
Code-Stil nicht oder nur mühsam unterstützt, ist nervig.  Es geht dann 
viel Zeit drauf, die Einrückungen wieder hinzubiegen.  Oft sieht man das 
beim

- Öffnen eines neuen Blocks
- Schliessen eines Blocks
- Brechen langer Zeilen (In Makros, Parameterlisten, Klauseln, ...)
- Einrückung mehrzeiliger Makros
- Fehlende Möglichkeit, Leerzeichen statt TABs zum Einrücken zu
  verwenden
- Automatisches Einrücken einzelner Zeilen oder Blöcke anhand des
  aktiellen Stils und etvtl. auch passend zum Kontext, etwa korrektes
  Einrücken von Code-Schnippel in Kommentaren.

> Anders machen es die Buchautoren auch nicht.

Ich behaupte mal der Autor eines Romans hat mit dessen Schriftsatz und 
Typographie rein garnix zu tun :-)

Leider sieht es so aus, als wären Typographie sowie Text- und Bildsatz 
bei vielen Seitenbetreibern ziemlich egal :-(

[Mikel M. (mikelm)]

Lothar Miller schrieb:

> Die erste. Weil ich zwischenzeitlich zwar unglaublich brrrreeeeiiite
> Monitore bekomme, aber leider mit nur sehr geringer Bildschimhöhe.

dann hast du Dir einfach einen falschen gekauft. Mein Notebook  hat 1200 
in der Höhe und das ist auch gut so. Und darum darf ich mir auch den 
übersichtlicheren 2ten Programmierstiel erlauben. 64Zeilen sind schon 
was feines. am Desktop hab ich über 80 Zeilen. als Programmierer achtet 
man eben darauf was man sich besorgt und ob man damit arbeiten oder 
spielen will.
 Auf dem Tablet hab ich die zwar nicht, aber das kann man ja auch drehen 
und dann hab ich sogar noch etwas mehr in der Höhe.

> Und eine Funktion, die nicht auf 1 Bildschirmseite passt, ist schon per
> Definition unübersichtlich, weil nicht überschaubar...
 Ich persönlich bin der Meinung das ein Sinnabschnitt nicht drüber gehen 
sollte von dem es durchaus mehrere in einer Funktion geben darf. Wobei 
damit gemeint ist ein Block auf sehr kleiner Verschachtungstiefe.

func()
{
  { grosser sinnblock }
  { noch nen grosser oder kleiner }
  { evt noch einer }
}
 ... aber hängt auch vom Projekt ab wie man es macht.


Autor: W.S. (Gast) schrieb
>So richtig zur Hochform kommt die obige Schreibweise aber erst dann,
>wenn man Quellen hat, wo jemand einem einen richtigen Haufen
>geschachtelter Blöcke unterschiedlichster Machart hinterlassen hat
 Es war dann meist nicht jemand, obwohl es solche Leute auch gibt, 
sondern verschiedene Leute, die meinten ihren eignen Stil einbringen zu 
müssen. (solche Leute sollte man direkt erschießen äähm entlassen)

 Ein absolutes NOGO ist wenn ein Format in einem Source existiert, dann 
in einem anderen Stil weiterzuschreiben. Wenn ein Stil vorgegeben ist, 
ist dieses auch beizubehalten und so weiterzumachen, oder man formatiert 
den ganzen Source um.

[Yalu X. (yalu) (Moderator)]

Mikel M. schrieb:
> Lothar Miller schrieb:
>
>> Die erste. Weil ich zwischenzeitlich zwar unglaublich brrrreeeeiiite
>> Monitore bekomme, aber leider mit nur sehr geringer Bildschimhöhe.
>
> dann hast du Dir einfach einen falschen gekauft. Mein Notebook  hat 1200
> in der Höhe und das ist auch gut so.

Das ist sogar sehr gut. Aber wo gibt es solche Notebooks heute noch zu
kaufen, außer im Trödelladen?

Ich habe zwei 1200er-Notebooks, ein altes und ein uraltes. Wenn ich
wollte, könnte ich vielleicht auch noch ein ururaltes bekommen. Gerne
würde ich mal wieder ein neues haben. Aber leider ist es bei den
Notebooks wie bei den abgepackten Lebensmitteln: Die Preise bleiben zwar
die gleichen, aber man bekommt 10% weniger Inhalt.

Mikel M. schrieb:
> Ein absolutes NOGO ist wenn ein Format in einem Source existiert, dann
> in einem anderen Stil weiterzuschreiben. Wenn ein Stil vorgegeben ist,
> ist dieses auch beizubehalten und so weiterzumachen, oder man formatiert
> den ganzen Source um.

Volle Zustimmung!

[Sven K. (oog)]

Yalu X. schrieb:
> Mal etwas avantgardistisch:
> if(x>5)                                                                {
>   a = 0                                                               ;
>   b = 1                                                               ;}
> else                                                                   {
>   a = 2                                                               ;
>   b = 3                                                               ;}
> funktion(a, b)                                                        ;
>
> Alle hässlichen Semikola und geschweiften Klammern werden dorthin ver-
> bannt, wo sie das Auge kaum noch stören, vom Compiler aber noch gesehen
> werden.

Mit etwas Kreativität kann man die geschweiften Klammern ganz 
eliminieren. Den folgenden Code habe ich nicht getestet, aber er 
compiliert zumindest ohne Fehlermeldung.

#define then {
#define endif }
#define else }else{

void test(int i){
  if (i==1) then
    PORTC += 1;
    PORTD += 1;
  else
    PORTC -= 1;
    PORTD -= 1;
  endif
}

[Checker Bunny (Gast)]

Ich lach mich tot. Die sinnlosesten Threads bringen es auf die meisten 
Beiträge ;-)

Meine Meinung dazu:
Im privaten Bereich ist es wohl ziemlich egal.

Im professionellen Bereich auch, aber Coding Rules sollten vorschreiben 
wie, damit es im Team auf dieselbe Weise geschieht (Grund: hauptsächlich 
Readability)