Wie rückt man Quell code richtig ein `?

...immer die öffnende { in eine neue zeile. niemals K&R style oder so'n mist!

EXDW

einrueckungen schoen mit tab, dann passts im jeden editor immer schoen
und das der { auf eine neue zeile gehoert find ich voellig normal
ist viel angenehmer fuer das auge wenn mehr luft da ist, dann wird man nicht so von code "erschlagen"
seber habe ich lange mit "bla () {" geproggt, bis ich das einfach als unangenehm enpfand, ich hab lieber eine leerzeile zuviel als zu wenig

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

int good()
{
    return (blubb) ? 1 : 0;
}

nur ein kleines beispiel
es gibt abartig viele moeglichkeiten code zu schreiben, man kann auch alles in einer linie schreiben #ggg

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!