Umfrage: Welchen Indent style verwendet ihr

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.

@ Dravere

Kleine Korrektur.

Tabs nutze ich zum Einrücken nicht, d.h. nutze ich schon, aber ich lasse sie von meinem Editor in Whitespaces umwandeln.

Der Grund ist der, daß das nutzen von Tabs schlechter Programmierstil ist.

asc schrieb:

Den Stil hatte ich mir abgewöhnt, da bei unterschiedlich langen Funktionsnamen das Auge ständig springen muss.

Ja, so habe ich das noch gar nicht gesehen, das leuchtet ein.

Die fortschritlich christliche Entwicklergemeinschaft e.V. hat alle genannten Indent Styles verglichen und ist zum Ergebnis gekommen, dass die Augen und Fingerbewegungen beim der Allman Style denen beim Rosenkranz beten am ähnlichsten sind und forciert nun die Verwendung dieses Styles.

DEvent

Indent Style schrieb:

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.

Vorbildlich
Ich verwende auch den

Allman style

und ebenso wie Indent Style bei allen If, While und For die {} setzen, allerding weniger wegen dem Compiler. Wenn der Compiler wegen sowas durcheinander kommt, dann sollte man diesen wegschmeisen. Es ist eher fuer den Lesen, damit er nicht durcheinander kommt.

DEvent schrieb:

Wenn der Compiler wegen sowas durcheinander kommt, dann sollte man diesen wegschmeisen.

ausser bei sprachen, bei denen einrückung strukturelement ist, kannst du auch alles in eine zeile schreiben. das 'nem compiler ziemlich egal.

Indent Style schrieb:

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

max. 80 zeichen pro zeile sind scheints aus der mode

alter hase schrieb:

Indent Style schrieb:

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

max. 80 zeichen pro zeile sind scheints aus der mode

Ja, zumindest bei mir.

80 Zeichen sind halt schon wenig und einen direkten Nutzen hat man nicht davon wenn man sich daran hält.
Niemand mehr programmiert direkt in der Konsole und die, die es z.b. unter Linux dennoch tun, die nutzen dann hoffentlich auch den VESA Framebuffer und der kann in höheren Grafikmodi auch mehr als 80 Zeichen pro Zeile darstellen.

Außerdem, Platz in der breite hat man bei modernen Widescreen Monitoren genug.
Aber der Platz in der Höhe ist schon stark eingeschränkt und gerade der sorgt ja für den größeren Überblick.

Daher macht es Sinn, wenn man die Breite für Parameter möglichst ausnutzt
und nicht alles untereinanderstellt nur weil man die 80 Zeichenlänge einhalten will.

DEvent

Indent Style schrieb:

alter hase schrieb:

Indent Style schrieb:

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

max. 80 zeichen pro zeile sind scheints aus der mode

Ja, zumindest bei mir.

80 Zeichen sind halt schon wenig und einen direkten Nutzen hat man nicht davon wenn man sich daran hält.
Niemand mehr programmiert direkt in der Konsole und die, die es z.b. unter Linux dennoch tun, die nutzen dann hoffentlich auch den VESA Framebuffer und der kann in höheren Grafikmodi auch mehr als 80 Zeichen pro Zeile darstellen.

Da muss ich entschieden widersprechen. Zum einen hat nicht jeder einen breiten Monitor, zum anderen haben moderne IDEs links und rechts Fenster (fuer Typenuebersicht, Klassenuebersicht, usw, siehe Eclipse) und zum dritten fuehrt die Regel der 80 Zeichen dazu, dass Verschachtelungen flach gehalten werden (also das nicht mehr als 3 oder 4 If-Verschachtelungen benutzt werden).

find halt vertikales scrollen besser als horizontales. ich hab kein widescreen, aber zwei monitore. das gute an files, die nur 80 zeichen haben, man kann neben dem editor noch nen file browser und ne konsole offen haben, oder sonst was. nach unten scrollen muss man eh ab ner gewissen zeilen zahl.

audacia

alter hase schrieb:

find halt vertikales scrollen besser als horizontales. ich hab kein widescreen, aber zwei monitore. das gute an files, die nur 80 zeichen haben, man kann neben dem editor noch nen file browser und ne konsole offen haben, oder sonst was. nach unten scrollen muss man eh ab ner gewissen zeilen zahl.

Das sehe ich ähnlich. Nur weil man einen Breitbildmonitor hat, muß man nicht geltende und sinnvolle Standards brechen und ihn in voller Breite mit Codezeilen füllen. Oder schreibt ihr neuerdings eure Diplomarbeiten auch im Breitbildformat?
Zudem ist auch die Codedichte in diesem Falle geringer, da nur verhältnismäßig wenige Zeilen länger als 80 Zeichen werden; das drosselt die Lesegeschwindigkeit gewöhnlich etwas.

(Allerdings muß ich fairerweise anfügen, daß es gerade in C++ schwerfällt, 80 Zeichen einzuhalten. Zuweilen wäre die Anhebung auf 100 ganz förderlich, da einfach allzuoft Zeilen wie
for (std::map <KeyT, ValueT>::const_iterator i = theMap.begin (), e = map.end; i != e; ++i) auftauchen.)

Dravere

audacia schrieb:

(Allerdings muß ich fairerweise anfügen, daß es gerade in C++ schwerfällt, 80 Zeichen einzuhalten. Zuweilen wäre die Anhebung auf 100 ganz förderlich, da einfach allzuoft Zeilen wie
for (std::map <KeyT, ValueT>::const_iterator i = theMap.begin (), e = map.end; i != e; ++i) auftauchen.)

Ich probiere auch immer die 80 einzuhalten, habe aber ein Maximum von 120 eingestellt, wo es mir dann eine gestrichelte Linie hinzeichnet (danke VAX).

Allerdings so eine Zeile würde ich auseinander nehmen:

typedef std::map<KeyT, ValueT> TheMap;

// ...

typename TheMap::const_iterator iter = theMap.begin();
typename TheMap::const_iterator end = theMap.end();

for(; iter != end; ++iter)
{
   // ...
}

@C-Chinesisch,
Man kann es auch übertreiben
Es gibt einfach Fälle, wo es besser erscheint. Zum Beispiel auch bei der Defintion von Konstanten, mag ich das sehr:

class Foo
{
public:
  static int const CONSTANT_ZERO    = 0;
  static int const CONSTANT_ONE     = 1;
  static int const CONSTANT_TWO     = 2;
  static int const CONSTANT_THREE   = 3;
  static int const CONSTANT_FOUR    = 4;
  // ...
  static int const CONSTANT_EIGHT   = 8;
  // ...
};

(so sinnfrei das Beispiel nun auch ist)

@asc,
Noch ein gutes Argument, muss mir das mal anschauen, ob ich das nicht auch anders mache.

Grüssli