Umfrage: Welchen Indent style verwendet ihr

Und warum?

Mögliche Antworten:

K&R style

K&R style Variant: 1TBS

Allman style (bsd in Emacs)

BSD KNF style

Whitesmiths style mit Einrückung des Funktionskörpers

Whitesmiths style ohne Einrückung des Funktionskörpers

GNU style

Horstmann style

Pico style

Banner style

Alle Stylearten die hier als Antwortmöglichkeit angegeben sind, sind
in diesem Wikipedia Artikel definiert:
http://en.wikipedia.org/wiki/Indent_style

Wenn keiner der Styles auf euren Style zutrifft, dann
wählt denjengigen, der eurem am nächsten kommt und schreibt dazu,
daß ihr von dem leicht abweicht und was genau diese Abweichung beinhaltet.

Ich persönlich bevorzuge den Allman style (bsd in Emacs).

PS: Vielleicht könnte ein Mod aus diesem Thread noch eine richtige Umfrage mit Abstimmergebnis machen.

JustAnotherNoob

Whitesmiths style mit Einrückung des Funktionskörpers
edit: danke, jetzt kenn ich den Namen xD

Allman style (bsd in Emacs)

Visual Studio rückt auch so ein, und das ist gut so. :xmas2:

audacia

wc schrieb:

Allman style (bsd in Emacs)

asc

Es gab schon einmal eine Umfrage mit einen ähnlichen Hintergrund.
Und die Frage nach dem warum, hast du selbst nicht beantwortet.

Indent Style schrieb:

Allman style (bsd in Emacs)

Zumindestens ähnelt mein Style diesen am ehesten. Wobei ich neben der Klammereinrückung mir auch das umbrechen und einrücken der Parameter angewähnt habe:

void IrgendeineKlasse::Foo(
    std::string const & param1,
    int param2,
    double param3)
{
    if(param2 < 42)
    {
        TueDies();
    }
}

cu André

GNU-Fan

Ich persönlich bevorzuge den "Allman style (bsd in Emacs)".

Den GNU-Style mag ich eigentlich überhaupt nicht leiden, aber in der Praxis verwende ich den am häufigsten, da fast alle GNU Projekte ihn benutzen.
Und man sollte selbstverständlich den Stil des Projektes konsistent halten.

ich: allman-style, sieht am übersichtlichsten aus.

pointercrash**

Allman style (bsd in Emacs)

Indent Style schrieb:

Und warum?

Der Auto- Indenter (eigentlich Completer) meines Lieblingseditors macht's so. Kann man zwar ändern, aber wenn man sich daran gewöht hat, hält man alles Andere für unübersichtlich, ob's nun real so ist oder nicht.
Edit: Ahja, fällt mir erst jetzt auf: Es ist so angenehm Pascal"ig". Statt Whitespaces ziehe ich zudem ein Tab- Raster vor. Spart Platz und ist leichter reformatierbar.

dust

ich: allman-style, sieht am übersichtlichsten aus.

dito.

asc

Mich verwundert das bislang fast alle den "allman-style" nennen, und der "K&R style" oder Ableger davon kaum genannt werden. Bei der letzten Umfrage war dieser Klammerstil deutlich im Vorteil...

Blue-Tiger

allman (mit Tabs statt Spaces)

asc schrieb:

Mich verwundert das bislang fast alle den "allman-style" nennen, und der "K&R style" oder Ableger davon kaum genannt werden. Bei der letzten Umfrage war dieser Klammerstil deutlich im Vorteil...

man darf sich ja wohl stilistisch verbessern. ausserdem verwenden k&r doch nur totale underground 1337 haxx0rs, nach dem motto: if code was hard to write, it must be hard to read!

Ich konnte meinen Stil nicht finden, welcher Kategorie würdet ihr ihn zuordnen?

template< typename classType >
int funktionMitLangemNamen( classType & firstParam, int secondParam,
                            const std::string & thirdParam )
{
    if( ( secondParam * 2 ) != 100 )
    {
         return 0;
    }
    else
    {
        for( int i = 0; i < 10; ++i )
        {
            firstParam += thirdParam;
        }
    }
    return 1;
}

^^allman, würde ich sagen.

zwutz

Allman (obwohl ich ihn eher als ANSI-Style kenne)

Eingerückt wird mit Tabs, eventuelle weitere Formatierung (wie bei umgebrochenen Funktionsaufrufen) werden mit Leerzeichen gemacht

Dravere

Wohl auch am ehesten:

Allman style

Sehr wahrscheinlich habe ich allerdings ein paar kleinere Unterschiede. Ich kenne allerdings den Style jetzt nur aus der Wikipedia Beschreibung und die ist ja wohl kaum vollständig
Ich verwende auch Tab und gebe mehreren Parametern eine neue Zeile. Allerdings ein wenig anders als asc:

void foo(int param1,
         char param2,
         std::string const& param3)
{
}

Manchmal sogar so:

void foo(int                param1,
         char               param2,
         std::string const& param3)
{
}

Grüssli

asc

Dravere schrieb:

Ich verwende auch Tab und gebe mehreren Parametern eine neue Zeile. Allerdings ein wenig anders als asc:

Den Stil hatte ich mir abgewöhnt, da bei unterschiedlich langen Funktionsnamen das Auge ständig springen muss. Wobei ich das Einrücken der Parameternamen auf eine Ebene teilweise auch mache

abc.w

Dravere schrieb:

Manchmal sogar so:

void foo(int                param1,
         char               param2,
         std::string const& param3)
{
}

Diesen Still nenne ich "C-Chinesisch". Ich nehme an, manche benutzen es, um wahrscheinlich anderen, die jahrelang gerne von links nach rechts lesen, ein wenig zu ärgern. Das geht ja meistens noch weiter, z.B. so:

void foo(int                param1,
         char               param2,
         std::string const& param3)
{
    int i =                 0     ;
    int j =                 1     ;
    return                  result;
}

Und wenn jemand besonders sadistisch veranlagt ist, dann nimmt er einen Editor, der im Quellcode gemischt Tabulatoren und Leerzeichen einfügt. Das sieht in 99 von 100 Editoren oder Debuggern dann so aus:

void foo(int                                                           param1,
         char       param2,
         std::string const&                             param3)
{
    int i =                                                                0    ;
    int j =        1                            ;
    return                  result;
}

hm eigentlich mach ich im groben den BSD KNF style. aber nur mit 4 leerzeichen statt tabs. (pfui zu tabs :p)

if(true) {
    foo();
}

ich find das macht die blocks logischer, wenn die schliessende klammer wie eine leerzeile nach nem abschnitt wirkt. mach ich bei texten auch so.
das } else { mach ich nie auf eine linie:

if(true) {
    foo();
}
else {
    bar();
}

und linien die ich umbrechen muss, rück ich normalerweise um zwei mal die normale einrückung ein, um sie von blocks zu unterscheiden. parameterlisten untereinander hab ich mal gemacht, aber das wurd mir zu 'wüst'. jetzt brech ich die halt um und mach unten weiter.

void foobar(int blalbalalalbllala,
        verylongtypename blalalaldlblbablablablaa) {
    foo();
    bar();
    if(true) {
        blubb();
    }
}

ganz selten gibts aber mal sowas:

foo() if true;

Dravere schrieb:

Wohl auch am ehesten:

Allman style

Sehr wahrscheinlich habe ich allerdings ein paar kleinere Unterschiede. Ich kenne allerdings den Style jetzt nur aus der Wikipedia Beschreibung und die ist ja wohl kaum vollständig
Ich verwende auch Tab und gebe mehreren Parametern eine neue Zeile. Allerdings ein wenig anders als asc:
void foo(int param1,
         char param2,
         std::string const& param3)
{
}

Ich finde deinen Stil auch besser als den von asc, denn die Funktionsnamen bleiben so sauber von den Parametern getrennt.

Und ich nutze diesen Stil sogar selber, aber nur dann, wenn die Parameterliste zu breit wird.

Aber in Zweiten von hohen Auflösungen und Widescreen habe ich da sehr viel Platz.

Manchmal sogar so:

void foo(int                param1,
         char               param2,
         std::string const& param3)
{
}

Ja, ich auch.

Und zur Frage von asc.
Ich nutze den Allman Style weil ich es mag, wenn die geschweiften Klammern einen Block schön einschließen, dabei sichtbar bleiben, nur eine eigene Zeile nutzen und bei der Einrückposition anfangen wo auch die letzte Funktion davor angefangen hat.

Für eine gewissen Zeit habe ich auch nur mal den K&R Style verwendet, hauptsächlich weil das der JBuilder von Borland so voreingestellt hatte,
aber als ich dann den JBuilder durch Eclipse ersetzte habe ich mir das wieder abgewöhnt.

Dennoch muß ich sagen, daß ich if Blöcke grundsätzlich in geschweifte Klammern setze, auch dann, wenn wenn sie nur einen Ausdruck haben.

Z.B. so:

if (true)
{
  machwas();
}
else
{
  if (true)
  {
    machmehr();
  }
  else
  { 
    machnixmehr();
  }
}

Das verhindert, daß der Compiler bei den IF Blöcken Ratespielchen spielt, welcher denn nun jetzt Vorrang hat.