Wie rückt man Quell code richtig ein `?

thordk

int evenbetter()
{
    if( blubb )
        return 1;
    else
        return 0;
}

*john 0

liederwams on tour schrieb:

vielleicht so ?

So nun auch noch meine Meinung dazu.

#include <iostream>

class test {
    int eingabe;
    int zurueck;
public:
    void start();
    void anweisung();
};

void test::start() {
    std::cout << "(1) Programm starten\n";
    std::cin  >> eingabe;

    if (1 == eingabe) {
        anweisung();
    }
}

void test::anweisung () {
    std::cout << "Sie sind jetzt in der Klasse test und in der funktion anweisung() \n";
    std::cout << "(1) Zurueck zum Anfang in die Funktion start()\n";
    std::cin  >> zurueck;
}

int main () {
    int zurueck;

    do {
        test a;
        a.start();
    } while (1 == zurueck);

    system("PAUSE");
}

Die öffenden Klammer "{" empfand ich schon immer als Rauschen, eine Folge von zu viel Modula-II. Da schiebe ich nur dann in einen neue Zeile, wenn vorher ein extrem langer Initblock kommt.

queer_boy

thordk schrieb:

int evenbetter()
{
    if( blubb )
        return 1;
    else
        return 0;
}

auf die gefahr hin, dass nieman diesen genialen sarkasmus in richtung mr. evil mitbekommen hat: return blub .

Hallo,

ich schließe mich voll und ganz ~john an.

Die öffnenden Klammern gehören ans Zeilenende.
Ich versteh gar nicht, warum es so viele gibt, die es anders machen.

Wenn man vertikal mit dem Auge hoch geht sieht man sofort die zugehörige
Kontrollstruktur und nicht noch ne störende öffnende Klammer.

Das mit den Leerzeichen statt Tabs ist ja wohl nen schlechter Scherz

Gruß,
CSpille

sri

CSpille schrieb:

Die öffnenden Klammern gehören ans Zeilenende.
Ich versteh gar nicht, warum es so viele gibt, die es anders machen

Mir geht es genau anders herum.

CSpille schrieb:

Ich versteh gar nicht, warum es so viele gibt, die es anders machen.

Ich schon. Es gefällt ihnen halt besser, persönlicher Vorzug eben. Ich finde Klammern am Zeilenende auch hässlich und unübersichtlich.

Aber Hautpsache, ihr macht dann nach nem if nen Abstand vor der Klammer:

if (bla)

oder noch schlimmer

if ( bla )

:p

Und dann vielleicht noch bla+i anstatt bla + i.
Übersichtlichkeit muss sein, aber nicht am falschen Platz und dann noch wo anders damit sparen

Aber jedem das Seine.

MfG

virtuell Realisticer

Morgen,

das ist Geschmackssache.

gruss
v R

virtuell Realisticer schrieb:

das ist Geschmackssache.

das ist nur die halbe wahrheit. die grundlegende prämisse, dass die einrückung der programmlogik entspricht, muss in jedem fall erfüllt sein. ob man dann mit 2 leerzeichen, 1 tab einrückt und die klammern in eigene zeilen setzt ist dann vielleicht geschmacksache.

void
funktion
(int a,int b) { int 
    c
        =a*b
;
return
    c
; }

irgendjemand auf der welt findet das bestimmt schön, somit trifft es seinen geschmack. aber sinnvoll ist es nicht, und wer so einrückt kann nicht programmieren.

mir persönlich fällt es sehr schwer, mit code zu arbeiten, bei dem die öffnende geschweifte klammer nicht in einer eigenen zeile steht. ich kann solchen code einfach nicht lesen.

So in etwa machen das die Profis:

#include <iostream>
class _{private:int __,___;public:int ____();int _____();};int _::____(){std::cout<<"(1) Programm starten\n";std::cin>>__;switch(__){case 1:_____();}return 0;}int _::_____(){std::cout<<"Sie sind jetzt in der Klasse _ und in der funnktion _____() \n";std::cout<<"(1) zurueck zum Anfang in die Funktion ____()\n";std::cin >>___;return 0;}int main(){int ___;do{_ ______;______.____();}while(___==1);}

Da das Design der Seite nun eh zerstört ist, wie würdet ihr es schreiben:

Constructor::Constructor() : a(a_), b(b_), c(c_), d(d_), e(e_), f(f_), g(g_), h(h_), i(i_), j(j_), k(k_), l(l_), m(m_), n(n_), o(o_), p(p_), q(q_), r(r_), s(s_), t(t_), u(u_), v(v_), w(w_), x(x_), y(y_), z(z_)
{
    ;
}

oder 2.

Constructor::Constructor() : a(a_), b(b_), c(c_), d(d_), e(e_), f(f_), 
                             g(g_), h(h_), i(i_), j(j_), k(k_), l(l_), 
                             m(m_), n(n_), o(o_), p(p_), q(q_), r(r_), 
                             s(s_), t(t_), u(u_), v(v_), w(w_), x(x_), 
                             y(y_), z(z_)
{
    ;
}

Ich würd die 1. Variante nehmen, der seitliche Scrollbalken is ned umsonst da, und so bleibt es übersichtlicher find ich.

MfG

Th

Seitliches Scrollen nervt aber beim Code-Review.

Ich mach's dann lieber so:

Constructor::Constructor(...) // <- Parameterliste a_, b_, c_ etc. fehlt ja auch noch!
  : a(a_), b(b_), c(c_), d(d_), e(e_), f(f_), 
    g(g_), h(h_), i(i_), j(j_), k(k_), l(l_), 
    m(m_), n(n_), o(o_), p(p_), q(q_), r(r_), 
    s(s_), t(t_), u(u_), v(v_), w(w_), x(x_), 
    y(y_), z(z_)

Aber wenn eine Klasse wirklich so viele Member hat, dann hat man meistens sowieso einen Design-Fehler!!!
Dann sollte man besser Unterklassen/-strukturen erstellen und an diese dann die Parameter weiterleiten.

C++ Forumbot

Dieser Thread wurde von Moderator/in evilissimo aus dem Forum C++ in das Forum Rund um die Programmierung verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Richtig einrücken tut man mit indent (oder das was die IDE halt so mitliefert) machen. Wie das dann genau aussehen soll ist entweder vom Projekt gesetzt, oder

virtuell Realisticer schrieb:

Geschmackssache

dooooomi

#include <iostream>

class test
    {
    int eingabe;
    int zurueck;
public:
    void start();
    void anweisung();
    };

void test::start()
    {
    std::cout<<"(1) Programm starten\n";
    std::cin>>eingabe;
    if(1==eingabe)
        {
        anweisung();
        }
    }

void test::anweisung()
    {
    std::cout<<"Sie sind jetzt in der Klasse test und in der funktion anweisung() \n";
    std::cout<<"(1) Zurueck zum Anfang in die Funktion start()\n";
    std::cin>>zurueck;
    }

int main()
    {
    int zurueck;
    do
        {
        test a;
        a.start();
        }
    while(1==zurueck);
    system("PAUSE");
    }

Was haltet ihr davon?

Und nein, das habe ich mir nicht ausgedacht, sondern der Code, an dem ich derzeit arbeite(n muß), ist tatsächlich so formatiert...

Hi

Schlecht!

Bye

virtuell Realisticer

Nabend,

der mob schrieb:

virtuell Realisticer schrieb:

das ist Geschmackssache.

das ist nur die halbe wahrheit. die grundlegende prämisse, dass die einrückung der programmlogik entspricht, muss in jedem fall erfüllt sein.

Die Programmlogik hat nicht im geringsten etwas mit der Einrueckung zu tun.

ob man dann mit 2 leerzeichen, 1 tab einrückt und die klammern in eigene zeilen setzt ist dann vielleicht geschmacksache.
void
funktion
(int a,int b) { int 
    c
        =a*b
;
return
    c
; }
irgendjemand auf der welt findet das bestimmt schön, somit trifft es seinen geschmack. aber sinnvoll ist es nicht, und wer so einrückt kann nicht programmieren.

Das ist voelliger bloedsinn. Wie kommst du nur auf die Idee, die Faehigkeit
programmieren zu koennen am Style der Einrueckung fest zu machen?

mir persönlich fällt es sehr schwer, mit code zu arbeiten, bei dem die öffnende geschweifte klammer nicht in einer eigenen zeile steht. ich kann solchen code einfach nicht lesen.

Das ist dann aber dein Problem und nicht das Problem eines anderen.

Dir bleibt in diesem Falle nichts weiter uebrig, als zu ueben, auch anderen
Codestyle lesen zu koennen.

Was haltet ihr davon?

Gerade passend zum Thread. Aber was andere oder du davon halten ist letztlich
egal. Wenn ihr in eurem Projekten oder speziell in diesem Projekt kein Codestyle
vorgegeben und auch nicht abgesprochen habt, dann musst du eben in den sauren
Apfel beissen und damit leben. Fakt ist, es aendert erstmal nichts an der
Programmlogik, wie bereits behauptet worden ist und was andere davon halten
duerfte auch reichlich uninteressant sein, es sei denn es ist dir wichtig,
dass andere das genauso sehen wie du.

gruss
v R

quellcode immer von links nacj rechts einrücken.

richtiges enrücken ist nur unter linu möglich. alles andere ist billiges gefrickel und gottlos. So ist es, nur spo und nicht anders!

asc

dooooomi schrieb:

...
Was haltet ihr davon?

Und nein, das habe ich mir nicht ausgedacht, sondern der Code, an dem ich derzeit arbeite(n muß), ist tatsächlich so formatiert...

Das ist eine mögliche (nicht meine präferierte) Form der Einrückung. Wie schon erwähnt Geschmackssache. Zumindestens kann man den Zusammenhang erkennen und der Code ist nicht wild formatiert sondern nach einem Standard.

Mein persönlicher Stil ist eigentlich die Klammern auf der selben Ebene zu setzen wie das Schlüsselwort das den Block beginnt, Ausnahmen gibt es vielleicht wenn die Funktion ein Einzeiler ist (dann setze ich die öffnende Klammer der Fuktion auch mal direkt hinter den Funktionskopf. Und ich gehöre auch zu den Menschen die selbst Zugriffsmodifikator einrücken:

...
class A
{
    public:
        int foo();
        int foo2();
};

int A::foo() {
    return 4;
}

int A::foo2()
{
    ...
}

int main()
{
    foo();
    for(int i=0; i<10; ++i)
        foo2();
}

Wichtig ist meines erachtens das man unabhängig vom Stil die Ebenen des Programmflusses erkennt, und man nicht unbegrenzt scrollen muss (in der Regel
mache ich z.b. einen 4er Abstand bei neuen "Ebenen", und einen 2er falls ich
Code umbrechen muss).

cu André

virtuell Realisticer schrieb:

Die Programmlogik hat nicht im geringsten etwas mit der Einrueckung zu tun.

wow, das ist richtig. das hat allerdings auch niemand behauptet.

Das ist voelliger bloedsinn. Wie kommst du nur auf die Idee, die Faehigkeit
programmieren zu koennen am Style der Einrueckung fest zu machen?

weil eine einrückung dazu dient, die logik des programms zu visualisieren. wer das nicht versteht und davon grundlegend abweichend einrückt (etwa ausschließlich nach willkürlichen ästhetischen kritieren), der hat einen teil des gebiets der programmierung nicht verstanden.

mir persönlich fällt es sehr schwer, mit code zu arbeiten, bei dem die öffnende geschweifte klammer nicht in einer eigenen zeile steht. ich kann solchen code einfach nicht lesen.

Das ist dann aber dein Problem und nicht das Problem eines anderen.

ja, ebenfalls richtig. ich hätte vielleicht anmerken sollen, dass meine sich aussage auf die vorherige diskussion bezogen hat.

Dir bleibt in diesem Falle nichts weiter uebrig, als zu ueben, auch anderen Codestyle lesen zu koennen.

glücklicherweise meisten doch.

Fakt ist, es aendert erstmal nichts an der
Programmlogik, wie bereits behauptet worden ist

nö.