Wie rückt man Quell code richtig ein `?

Ups, so war's gemeint:

int correct()
{
  if(bla)
    return 1;
  else
    return 0;
}

Mr. Happy schrieb:

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);}

Du bist sicher ein Programmierer der alten Stunde, der mit Lochstreifen sein
Programm in den Rechner geladen hat.

dooooomi schrieb:

#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?

Ich finde es schlecht,
da man so die schließende Klammer vergessen könnte.

der mob schrieb:

das stimmt nicht. bei konsistenter, streng logischer einrückung hat tab durchaus vorteile ggü. space. ein konsistent und korrekt mit tabs eingerückter code sieht bei jeder beliebigen tabweite richtig aus.

ein wenig problematisch dabei ist allerdings, dass man mit blossem auge einem leerraum nicht ansehen kann, ob er sich aus spaces oder tabs zusammensetzt.

virtuell Realisticer schrieb:

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

Das macht mein Prof so.
O Ton:
[QUOTE]
Ob jemand programmieren kann, erkennt man daran, ob er richtig Einrücken kann.
Falsches Einrücken ist schlechter Programmierstil.
[QUOTE]

zwutz

Werth schrieb:

CSpille schrieb:

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

Bei meinem Prof gäbe es dafür Punktabzug wenn man Tabs verwendet.

Und was er auch nicht mag ist weniger als 2 oder mehr als 2 Leerzeichen.

D.h. NUR so wäre es korrekt:
int correct()
{
  if( blubb )
    return 1;
  else
    return 0;
}

das profs selten was von Programmieren verstehen, sollte eingehenst bekannt sein... diese Einstellung ist so ziemlich unterste Schublade

EXDW

dazu sei gesagt das ich find
tabs ja, aber nur zur einrueckung am zeile anfang, im text selber , zb
int a = 0;
da sollte alles leerzeichen sein

ps. ich les und durchwuele regelmaessig code von ~250 verschiedenen entwicklern, und alle machen das so das zu beginn tabs, amsonsten leerzeile
und das passt im jeden editor da jeder seine tab weite einstellen kann und genau das sieht dann immer genau richtig aus
{hab nu hier aber ne alles gelesen #gg}

ich hatte ne zeit lang auch immer nach ( und vor ) auch ein leerzeichen gemacht ( bla )
habs aber mitlerweile nicht mehr, hat kein besonderen grund, finds nur ohne besser

void bad () {
   for ( ;; )
      bla ();
}

void good()
{
    for(;;)
        bla();
}

btw - schon doof das man hier beim schreiben 4x leerzeichen machen muss #gg

Mr Evil schrieb:

void bad () {
   for ( ;; )
      bla ();
}

void good()
{
    for(;;)
        bla();
}

void better()
{
   for(;;)
   {
      bla();
   }
}

EXDW

najo, das ist auch wieder so eine sache, ich finds unnoetig da man es durch die einrueckung noch sieht, es macht nur sinn wenn man irgendwann evtl den rumpf erweitern will - wenns aber bei einer anweisung bleibt kann man sich das spaaren

rüdiger

Die einzig wahre Notation geht ohnehin so:

void a(int i) {
  for(;;)
    i += (a * b)/c;
}

void b(
  int i, int j, fooobarundsowas k,
  undsoweiter x)
{
  // ...
}

class x {
  int kk;
};

namespace a { namespace b {
  class u
    : public v
  {
  public:
    u(k const & n)
     : v(n)
    { }
  };
}}

template<typename T>
typename foo::bar::result_of<T>::typename
bar(T const &t) {
  return t.xy();
}

Und es ist wissenschaftlich bewiesen, dass alles andere böse ist! :xmas1:

asc

rüdiger schrieb:

Die einzig wahre Notation geht ohnehin so:

Schön uneinheitlich xD... (vor allem ob die Klammern nun auf einer eigenen Zeile stehen oder doch hinter den Elementen).

cu André