Wie rückt man Quell code richtig ein `?

vielleicht so ?

#include <iostream>
using namespace std;

class test
{
private:
int eingabe;
int zurueck;

        public:
        int start();
        int anweisung();

};

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

             switch (eingabe)
        {
             case 1:
             {
             anweisung();
             }
        }

return 0;
}

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

int main ()
{

int zurueck;

do
{
test a;
a.start();

}
while (zurueck==1);
   system("PAUSE");
}

Th

Scherzkeks

sri

Wenn Du diese Frage einmal an fünf Programmierer stellst, dann bekommst Du sechs verschiedene Antworten.

"Richtig" ist das, mit dem Du selbst am besten klarkommst. Es sei denn, Du arbeitest im Team mit anderen zusammen. Dann sollte man sich möglichst auf einen Stil einigen.

ok thx

@Th

Warum Scherzkekse ?

Weil du es eckstra falsch gemacht hast.

queer_boy

neuer block, neue ebene. höchstens drei ebenen, zwei reichen meistens.
keine tabs, sondern leerzeichen (pro einzug drei); private, public, case, default etc. gehören semantisch zu dem block "über" ihnen, d.h.: keine extra einrückung.

das beispiel in meinem stil:

#include <iostream>
using namespace std;

class test
{
private:
   int eingabe;
   int zurueck;

public:
   int start ();
   int anweisung ();
};

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

   switch (eingabe)
   {
   case 1:
      {
         anweisung();
      }
   }

   return 0;
}

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

int main ()
{
   int zurueck;

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

sri

queer_boy schrieb:

keine tabs, sondern leerzeichen (pro einzug drei); private, public, case, default etc. gehören semantisch zu dem block "über" ihnen, d.h.: keine extra einrückung.

Ich hasse Einrückungen mit Leerzeichen. Das erste, was ich mit fremden Code mache, ist ein "Tabify".

...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.