'int* x' 'int * x' oder 'int *x' ?



  • Eine variable pro Statement, nie mehrere.
    Dann hat man eine Menge Probleme weniger 😉



  • zwutz schrieb:

    von Lesbarkeit reden, aber int *a, *b, *c; schreiben...

    Ich habe von Lesbarkeit geredet, ja. Aber ich habe nicht gesagt, dass ich so Variablen deklariere (mach ich auch nicht mit Pointern). fricky hat trotzdem ein schönes Beispiel dafür gezeigt, wie man mit der anderen Variante eine schlechte Lesbarkeit erreichen kann. Auch finde ich es einfach optisch schöner, wenn der Dereferenzierungsoperator an der Variable dranklebt. Er zeigt ja schließlich auf diese Adresse. Also mach ich es auch bei der Deklaration so. Na ja... 🙂



  • Ich bevorzuge wiederum die erste Variante, mit dem Argument, dass es sich um einen Datentyp handelt, den ich ggf. mit einem typedef (oder was ganz anderem) ersetzen werde.
    Und um solche Stellen später mit Suchfunktionen wiederzufinden ist Shade's Argument ein Muß!



  • knivil schrieb:

    +fricky schrieb:

    ach ja, wenn man mehrere variablen in einer zeile anlegt, dann ist die zweite schreibweise besser:

    int *a, *b, *c;  // 3 pointer
    int* a, b, c;    // nur ein pointer, sieht verwirred aus
    

    Mache ich nie...

    ich eigentlich auch nicht. war auch nur ein beispiel dafür, dass das sternchen an's 'int' kleben doof ist.
    🙂



  • +fricky schrieb:

    ich eigentlich auch nicht. war auch nur ein beispiel dafür, dass das sternchen an's 'int' kleben doof ist.
    🙂

    Ne es war ein beispiel dafür dass mehrere variablen in einem statement zu definieren doof ist.

    ob
    int* p
    oder
    int *p
    ist sowas von egal.

    es gibt keinen logischen grund eine variante davon zu bevorzugen. also eine auswählen und dabei bleiben.

    ich finde
    char foo();
    häßlich und nehme deshalb
    char
    foo();



  • Shade Of Mine schrieb:

    ich finde
    char foo();
    häßlich und nehme deshalb
    char
    foo();

    ist bei mir genau umgekehrt, aber über geschmack lässt sich ja prima streiten.
    🙂



  • +fricky schrieb:

    Shade Of Mine schrieb:

    ich finde
    char foo();
    häßlich und nehme deshalb
    char
    foo();

    ist bei mir genau umgekehrt, aber über geschmack lässt sich ja prima streiten.
    🙂

    deshalb sagte ich ja:
    es gibt keine logischen argumente.



  • Shade Of Mine schrieb:

    mehrere variablen in einem statement zu definieren doof ist.

    Das würde ich so allgemein nicht sagen. Man kann durch mehrere Deklarationen in einem Statement gut deutlich machen, dass die Variablen inhaltlich zusammengehören und den selben Typ haben sollen. Besonders wenn sie ohnehin nur kurze Bezeichner haben und nicht kompliziert initialisiert werden, ist es auch nicht unübersichtlich oder schlecht lesbar.

    Ich wüsste jetzt nicht, was für Nachteile das haben sollte.

    Edit: "mehrere Deklaratoren/Variablen in einer Deklaration" muss es richtig heißen. Deklarationen sind eigentlich keine Statements.



  • namespace invader schrieb:

    Ich wüsste jetzt nicht, was für Nachteile das haben sollte.

    Das menschliche Auge kann es nicht so gut erfassen. Wenn ich zB nach "z" suche und die Zeile

    Axis x, y, z;

    sehe, dann tue ich mir schwer das z sofort herauszulesen.
    ein
    Axis x;
    Axis y;
    Axis z;

    ist da deutlich leichter scannbar für das Auge.



  • Shade Of Mine schrieb:

    Axis x, y, z;

    sieht doch gut aus, 3 achsen, sieht man sofort. da hast du ein beispiel gewählt, das besonders gut als einzeiler aussieht.
    🙂



  • es gibt keine logischen argumente.

    Doch, die einen sagen "int*" ist der Datentyp "Zeiger auf int", waehrend "int *a" auf die Verwendung abziehlt, a derefenziert ergibt einen int. Beides sind gute Argumente (geschmacksneutral), fuer welche man sich letztendlich entscheidet ist dann aber wieder Geschmackssache.



  • Ich nehme immer

    int * p; //p ist pointer auf int
    

    Grund: Es liest sich schön von hinten nach vorne. Vor allem, wenn noch const im Spiel ist:

    int const *       p; //p ist pointer auf konstanten int
    int * const       p; //p ist konstanter pointer auf int
    int const * const p; //p ist konstanter pointer auf konstanten int
    

    🤡



  • Tachyon schrieb:

    Grund: Es liest sich schön von hinten nach vorne. Vor allem, wenn noch const im Spiel ist: 🤡

    Ja, wirklich schauderhaft, daß in C das Assignment wechselt. Meist links nach rechts, aber dann bei so "unwesentlichen" Dingen rechts nach links.

    int const *       p, q, r; //p ist pointer auf konstanten int
    int * const       p, q, r; //p ist konstanter pointer auf int
    int const * const p, q, r; //p ist konstanter pointer auf konstanten int
    

    Ich kann ad hoc nicht so einfach sagen, was pointer, was nur int. usw ist, wenn da drei Vars hinter so etwas klemmen, deswegen hat Shadys Beharren auf separate Deklarationen schon was für sich. Man programmiert ja nicht nur in C ... 😉



  • Tachyon schrieb:

    Ich nehme immer

    int * p; //p ist pointer auf int
    

    Grund: Es liest sich schön von hinten nach vorne. Vor allem, wenn noch const im Spiel ist:

    int const *       p; //p ist pointer auf konstanten int
    int * const       p; //p ist konstanter pointer auf int
    int const * const p; //p ist konstanter pointer auf konstanten int
    

    🤡

    sticky!!! - und die prioritätentabelle auch! 😉



  • pointercrash() schrieb:

    ... deswegen hat Shadys Beharren auf separate Deklarationen schon was für sich. Man programmiert ja nicht nur in C ... 😉

    Achso ja, das hätte ich noch dazu schreiben sollen: Selbstverständlich nur eine Variable pro Statement. 😉
    Schreibfaulheit führt selten zu verständlichem Code.



  • Aber es hat nichts mit Schreibfaulheit zu tun, so etwas vermeiden zu wollen:

    /* the x-coordinate of the point */
    double x;
    
    /* the y-coordinate of the point */
    double y;
    
    /* the z-coordinate of the point */
    double z;
    

    Das hat allenfalls Vorteile, wenn die Produktivität der Programmierer anhand der geschriebenen Codezeilen gemessen wird 🙂

    Dass es selten sinnvoll sein dürfte, Integer und Zeiger zusammen einem Statement zu deklarieren wie im Beispiel von pointercrash, ist ja keine Frage.



  • namespace invader schrieb:

    Dass es selten sinnvoll sein dürfte, Integer und Zeiger zusammen einem Statement zu deklarieren wie im Beispiel von pointercrash, ist ja keine Frage.

    Tatsächlich schonmal gesehen, war ein total vergurktes Projekt, das ich "aufräumen" sollte, vor solchen "Tricks" nebst unglaublichen Kommentaren strotzte :p und zudem ein wüster Mix aus C und C++ war. Ich habe nach ein paar Tagen 😕 entnervt aufgegeben 😞
    Ist halt eins der Handwerkszeuge, total unleserlichen Code zu schaffen. 😃



  • namespace invader schrieb:

    Aber es hat nichts mit Schreibfaulheit zu tun, so etwas vermeiden zu wollen:

    //x,y,z coordinates of point whatever
    double x;
    double y;
    double z;
    


  • //x,y,z coordinates of point whatever
    double x,y,z;
    

    Ist doch ok. Ich bin auch kein Freund von Mehr-Variablen-Deklarationen in einer Zeile, aber in solchen Fällen leidet die Übersicht imho nicht.



  • Wenn ich das mit den Pointer-Deklarationen bisher richtig beobachtet habe:

    Eine Typdeklaration besteht aus

    [Typ] [Bezeichner]
    also
    [int] [a]
    oder
    [Typ] [Bezeichner], [Bezeichner], ... [Bezeichner];
    

    Das dämliche an Pointern in C ist jetzt, dass sie so gesehen zum Bezeichner gehören!

    Deswegen:

    [Typ] [[Pointer]Bezeichner] => [int] [[*] p];
    oder
    [int] [[*] p1], [[*] p2];
    oder
    [int constant] [[* constant] p];
    

    hässlich, dämlich, aber C. 🙂

    Wenn das nicht irgendwo an einem Beispiel kollidiert, ist das wohl eine brauchbare Erklärung.
    "int * p" wäre dann wohl korrekt, "int *p" würde die Zugehörigkeit zum Bezeichner verdeutlichen, "int* p" wäre verwirrend.

    Steht das nicht im Standard genau beschrieben? Ich habe leider keinen zur Hand...


Anmelden zum Antworten