Wie findet ihr einen solchen Code-Stil?



  • Hallo, ich würde gerne eine Meinung wissen wie ihr einen solchen code-stil findet den ich neulich gesehen habe - der code macht nix:

    template <class T> int*
    Foo_Bar::Get_My_Line(int&   a,
                         int&   b,
                         int*   arr,
                         double c,
                         int    line)
    {
        int    az    = 0,
               bz    = 1,
               *arrb = NULL,
               cz    = 3;
    
        double u     = 3.3,
               g     = -1.9;
    
        arrb = Fill_Array(az, bz);
    
        for (int i = 0; i < 100; i++)
        {
            arrb[i] = -2;
        }
    
        return arrb;
    }
    


  • Gefällt mir persönlich nicht.



  • Ich finde ihn auch nicht so toll.



  • geht garnicht



  • für meinen geschmack ist die formatierung ein bisschen zu luftig, aber ansonsten ok, solange es konsequent durchgesetzt ist. der mangel an kommentaren und die scheiße benannten variablen sind hingegen schlecht, und das ist das, worauf es beim code-stil am meisten ankommt. ja, es ist egal dass das nur ein beispiel ist.



  • Stildiskussionen sind bei uns besonders beliebt. 🙂
    Deshalb wird es in diesem Thread auch oft passieren, dass das Gespräch in einen Flamewar auszuarten droht, und noch öfter, dass Leute sich gegenseitig darauf hinweisen, dass es sich um Geschmackssache handelt. 😃

    Also meine persönliche Meinung: Ich finde die Parameter-Deklarationen untereinander nicht gut. Solche eingerückten Deklarationen mache ich eigentlich nur in Klassen, aber dort ist auch genügend Abstand vorhanden. Wenn nämlich ein komplexerer Typ dazukommt, kannst du neu einrücken, sehr konsistent bist du damit nicht. Auch der Rückgabetyp auf einer separaten Linie gefällt mir nicht - ich finde es übersichtlicher, diesen in gleicher Zeile mit dem Funktionsnamen zu schreiben. Das template ist allerdings okay eine Zeile vorher.

    Innerhalb der Funktion verhält sich das Ganze ähnlich: Ich habe eigentlich nie Mehrfachdeklarationen. Bei mir kommt es auch nicht sehr oft vor, dass ich mehrere Variablen gleichen Typs nacheinander deklariere - und wenn doch, gebe ich den Typen jedes Mal an. Der Rest (Block-Einrückungen, Abstände) sieht für mich gut aus, das mache ich ähnlich.



  • nice!!!!!



  • Mein Stil:

    template <class T>
    int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
    						  double c, int line)
    {
    	int az = 0,
            bz = 1,
            *arrb = NULL,
            cz = 3;
    
        double u = 3.3, g = -1.9;
        arrb = Fill_Array(az, bz);
    
        for(int i = 0; i < 100; i++) {
            arrb[i] = -2;
        }
    
        return arrb;
    }
    


  • So, und nur so, meine Söhne und Töchter:

    template <class T>
    int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr, double c, int line)
    {
        int az = 0, bz = 1, cz = 3, *arrb = 0;
        double u = 3.3, g = -1.9;
    
        arrb = Fill_Array(az, bz);
    
        for(int i = 0; i < 100; i++)
            arrb[i] = -2;
    
        return arrb;
    }
    


  • Um die Ausgangsfrage ehrlich zu beantworten:

    beschissen



  • meine güte
    dagegen sehen meine Programme total "sauber" aus
    viel zu unübersichtlich und komplett falsch eingereiht wenn ihr mich fragt.
    also wenn der Programmierer da durchsteigt, soll er es doch machen. aber anderein punkto c++ sollte er nicht beraten, belehren, sonst machen die das genauso schlimm ^^.



  • Ich finde es eg ganz ok. Man liest halt eher von oben nach unten anstatt Zeilenweise. Besonders bei template Typen mache ich es desöfteren auch so, aber da wird auto ja bald Abhilfe schaffen.



  • Neuling1 schrieb:

    Hallo, ich würde gerne eine Meinung wissen wie ihr einen solchen code-stil findet den ich neulich gesehen habe

    das akkurate ausrichten von bezeichnern wäre mir viel zu anstrengend zu warten. und das geht doch sowieso spätestens beim zweiten programmierer kaputt.
    underscores UND camelcase finde ich auch sehr gewöhnungsbedürftig. entweder DasEine oder das_andere, aber nicht Beides_Gleichzeitig.
    die bezeichner sind kryptisch, und die magischen zahlen im code sind auch unschön.
    aber sonst ist alles super 🙂

    sdfsdf schrieb:

    Man liest halt eher von oben nach unten anstatt Zeilenweise.

    wo ist der unterschied?



  • meiner ist eher so

    template <class T>
    int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
                              double c, int line)
    {
        double u = 3.3;
        double g = -1.9;
        int cz = 3;
    
        int az = 0;
        int bz = 1;
        int *arrb = Fill_Array(az, bz);
        for (int i = 0; i < 100; i++)
        {
            arrb[i] = -2;
        }
        return arrb;
    }
    

    aber das läßt sich an diesem beispiel kaum zeigen. sowas wie "variablen so lokal wie möglich machen" und "eine funktion - ein zweck" ziehen allerhand anderes dann nach sich, zum beispiel nicht mehrere variablen in einer deklararion und arrb nicht mal auf vorrat mit NULL initialisieren.



  • hmm....also vielleihct sollte ihc meine gedanken dazu äußern.
    Ich versuche code immer möglichst untereinander zu schreiben weil das meiner Ansicht nach übersichtlicher ist. Wenn man z.B. in einer signatur mehr als 5 parameter hat dann muss man machmal 2 oder mehrmals lesen welcher paramter wo steht bzw. wie heißt weil man dann verrutscht mit den augen - geht mir so.
    So ähnlich meine ich es dann auch mit den datentyp-blöcken....man sieht doch eigentlich sofort wo welche variable steht. Natürlich bei 2 oder maximal 10 variablen ist das gut sichtbar aber bei mehr....dann wird wohl das design scheiße sein wird der ein oder andere sagen...kann sein ja.

    Mit den Camelcases und underscores kann ich bis heute nicht meine linie finden.

    Mir ist klar dass solche "wie sieht euer code aus"-fragen für die katz sind - aber dennoch beschäftigt mich auch so etwas bis heute unentwegt...



  • Neuling1 schrieb:

    Ich versuche code immer möglichst untereinander zu schreiben weil das meiner Ansicht nach übersichtlicher ist.

    Das ist wie du siehst Geschmackssache, ich persönlich schreibe die Deklaration von Parametern auch untereinander (wenn auch im anderen Stil):

    template <class T>
    int* FooBar::GetMyLine(
        int& a,
        int& b,
        int* arr,
        double c,
        int line)
    ...
    // Einrückungen ansonsten in etwa wie bei volkard
    

    Dazu muss man aber auch sagen, das ich in der Regel mit wesentlich längeren Datentypen und Bezeichnern arbeite (z.B. "std::vector<int> ressourceIds") und gleichzeitig versuche Zeilen nicht länger als 82 Zeichen (Wegen Ausdrucken - was ich selten mache, dennoch habe ich es mir so Angewöhnt) zu machen.

    Neuling1 schrieb:

    Wenn man z.B. in einer signatur mehr als 5 parameter hat...

    In der Praxis ist es bei mir äußerst selten wenn mehr als 3-4 Parameter verwendet werden (Ausnahme ggf. bei Konstruktoren).

    Die Angewohnheit pro Variablendeklaration eine Zeile zu verwenden und niemals mehr als eine Variable auf einmal zu deklarieren wirst du aber bei vielen sehen. Zudem ist es normal, das man Variablen erst bei ihrer ersten Verwendung deklariert.

    Neuling1 schrieb:

    Mit den Camelcases und underscores kann ich bis heute nicht meine linie finden.

    Unabhängig davon welchen Stil du wählst: sei konsequent!

    cu André



  • Neuling1 schrieb:

    Hallo, ich würde gerne eine Meinung wissen wie ihr einen solchen code-stil findet den ich neulich gesehen habe - der code macht nix:

    ...
    

    Erinnert mich an n scherzposting das ich neulich irgendwo gesehen hab:

    Es                              wäre
    lustig                          wenn
    du                             sehen
    könntest                         wie
    deine                          Augen
    behindert                        von
    links                           nach
    rechts                        hüpfen
    

    Mal ehrlich, findest du sowas leicht lesbar? Ich finds grauenvoll.

    volkard schrieb:

    meiner ist eher so

    template <class T>
    int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
                              double c, int line)
    {
        double u = 3.3;
        double g = -1.9;
        int cz = 3;
    
        int az = 0;
        int bz = 1;
        int *arrb = Fill_Array(az, bz);
        for (int i = 0; i < 100; i++)
        {
            arrb[i] = -2;
        }
        return arrb;
    }
    

    Mal abgesehn davon dass ich zu vermeiden versuche Funktionen mit zig Parametern, zu Anfang definierten und unbenutztn Variablen zu schreiben, siehts bei mir ähnlich aus 😉



  • volkard schrieb:

    meiner ist eher so

    template <class T>
    int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
                              double c, int line)
    {
        double u = 3.3;
        double g = -1.9;
        int cz = 3;
    
        int az = 0;
        int bz = 1;
        int *arrb = Fill_Array(az, bz);
        for (int i = 0; i < 100; i++)
        {
            arrb[i] = -2;
        }
        return arrb;
    }
    

    Genau den gleichen Stil hab ich auch. Ich finde es persöhnlich nicht gut, wenn mann mehrere Variablen in einer Zeile deklariert/definiert. Außerdem, eine Variable zu deklarieren und eine Zeile darunter sie definieren, finde ich schwachsinnig.

    pumuckl schrieb:

    Mal abgesehn davon dass ich zu vermeiden versuche Funktionen mit zig Parametern zu schreiben

    Die Frage ist auch, ob es Sinn ergibt.

    Wie gesagt, mein Stil is eig. wie volkard's, nur das ich noch versuche, wenn ich überhaupt soviele Parameter habe, sie in eine Zeile zu schreiben.

    mfg



  • Ja macht doch ne Wissenschaft draus! 😉

    Oder schreibt anständige Programme! :p
    Ersteres ist wohl einfacher ... 🙄



  • FreakY<3Cpp schrieb:

    Wie gesagt, mein Stil is eig. wie volkard's, nur das ich noch versuche, wenn ich überhaupt soviele Parameter habe, sie in eine Zeile zu schreiben.

    ups, ich auch. hab hier nicht drauf geachtet. aber bei über 80 zeichen breite breche ich dann doch mal um.

    0         1         2         3         4         5         6         7
    01234567890123456789012345678901234567890123456789012345678901234567890123456789
    int* Foo_Bar::Get_My_Line(int& a,int& b,int* arr,double c,int line)
    

    da war noch massig platz.


Log in to reply