Wie findet ihr einen solchen Code-Stil?



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



  • @volkard und rest: Also ihr macht auch Get_My_Line() und nicht getMyLine() oder get_my_line() ?

    Da ich noch nicht viel in der Industrie mit programmierung zu tun hatte frage ich mich eben wie es sauber wäre bzw. was die Leute gerne sehen an Stil.

    Zudem ist es normal, das man Variablen erst bei ihrer ersten Verwendung deklariert.

    hier würde ich gerne nochmal nachfragen:

    Also variablen erst deklarieren wenn sie unmittelbar gebraucht werden? So in etwa (sinnloses beispiel aber nur als frage)?

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


  • Die Benennung pass ich der Klasse an, bzw. wenn mir aufgetragt wird, folgenden Style zu nehmen, werd ich den nehmen. Aber ich mach es eig so:

    int* FooBar::get_my_line(int number)
    

    Ja so kommt es eig. öfters bei mir vor.

    Eine Variable erst zu benutzen wenn du sie brauchst, kannst du ruhig machen. Meistens mache ich es auch so.



  • Neuling1 schrieb:

    @volkard und rest: Also ihr macht auch Get_My_Line() und nicht getMyLine() oder get_my_line() ?

    die letzten beiden Varianten hab ich schon gesehen, die erste nicht. Also entweder CamelCase oder unter_striche 😉

    Neuling1 schrieb:

    Also variablen erst deklarieren wenn sie unmittelbar gebraucht werden?

    Ja. Zumindest nahe der Stelle wo sie deklariert werden. Dann muss man im Zweifel nicht erst hochscrollen um zu schauen von welchem Typ Variable xy nochmal war, und man hat nicht irgendwelche verwirrenden Deklarationen im Text stehen die an der Stelle noch garkeinen Sinn ergeben.



  • Neuling1 schrieb:

    @volkard und rest: Also ihr macht auch Get_My_Line() und nicht getMyLine() oder get_my_line() ?
    Da ich noch nicht viel in der Industrie mit programmierung zu tun hatte frage ich mich eben wie es sauber wäre bzw. was die Leute gerne sehen an Stil.

    ich nehmen nur KlassenName::funktionsName. aber richtung microsoft wirste oft KlassenName::FunktionsName sehen und in nder anderen reichtung gehts bis klassen_name::funktions_name
    und da gibt es kein besser oder schlechter, man macht einfach das, was im unternehmen üblich ist. kannst ja schlecht die bestehenden bibliotheken so verfummeln, daß der anwender dann

    void FooBar::GetMyLine(){
      foo_bar_base::get_my_line();
      if(Error) throw Foo_Bar_Exception(Error);
    }
    

    schreiben muß.



  • pumuckl schrieb:

    Neuling1 schrieb:

    Also variablen erst deklarieren wenn sie unmittelbar gebraucht werden?

    Ja. Zumindest nahe der Stelle wo sie deklariert werden. Dann muss man im Zweifel nicht erst hochscrollen um zu schauen von welchem Typ Variable xy nochmal war, und man hat nicht irgendwelche verwirrenden Deklarationen im Text stehen die an der Stelle noch garkeinen Sinn ergeben.

    Eine Funktion/Methode sollte auch nie laenger sein als eine Bildschirmseite (vielleicht noch zwei).



  • hartmut1164 schrieb:

    Eine Funktion/Methode sollte auch nie laenger sein als eine Bildschirmseite (vielleicht noch zwei).

    Das auch. wobei eine Bildschirmseite schon sehr viel ist, 10-15 Zeilen sind meist schon mehr als genug. Trotzdem gehören Deklarationen von Variablen dort hin wo sie verwendet werden, wo sie sinnvoll initialisiert werden können (meist erst unimttelbar vor der verwendung), und wo sie nicht aus dem Kontext gerissen werden (und der Kontext beginnt dort wo sie verwendet werden).



  • neulich im c-forum gefunden.

    //noch schnell compilierbar gemacht
    template<typename T>
    void toNull (T *arr,size_t size)
    {
    	for(size_t i=0;i!=size;++i)
    		arr[i]=0;
    }
    
    int main()
    {
        char szPlaintext[999], szCiphertext[999],c;
        char szKey[999];
        int i=0, j=0;
    
        toNull (szPlaintext, 999);
        toNull (szKey, 999);
        toNull (szCiphertext, 999);
    
        printf("Bitte geben sie den zu verschluesselnden Text ein!\n");
        gets(szPlaintext);
        printf("Bitte geben sie den Key ein\n");
        gets(szKey);
    
        c=*szPlaintext;
    
        while (c)
        {
            szCiphertext[i] = c^szKey[j];
            szCiphertext[i] += 65;
            i++;
            j++;
            if (szKey[j] == 0)
                j=0;
            c=szPlaintext[i];
        }
    
        for (j=0;j<i;j++)
            printf("%c", szCiphertext[j]);
    
        return 0;
    }
    

    ich würde wetten, daß das viel hübscher aussehen würde, wenn alle variablen so spät wie möglich angelegt werden würden-



  • volkard schrieb:

    neulich im c-forum gefunden.

    template<typename T>
    

    😕 😕



  • Ja dass man schleifenvariablen kontext-mässig setzt ist mir auch klar....also for(int i...) und nicht int i; for(i...). Aber ich frage mich ob es nicht übersichtlicher ist alle variablendeklarationen am anfang zu haben als block weil so weiß man ja wo sie zu finden sind immer. Wenn man irgndwo in der mitte ein variablendeklaration sucht und erst die ganze funktion bis an die stelle laufen muss wo sie deklariert wurde könnte das, vorausgesetzt die funktion ist länger, länger dauern.

    Andere Frage: Benutzt ihr Informationen für eure Variablennamen die euch den Typ verraten? Also so i für int und d für double oder p für Pointer:

    int iHouse;
    double dEpysilon;
    int* piMyArray;
    

    ?


Anmelden zum Antworten