Stilfrage: T& a oder T &a



  • Wie der Titel schon sagt, eine kleine Stilfrage. Bisher haben wir meist im Stil

    T& a oder char buffer* geschrieben. Allerdings würde folgendes natürlich so nicht funktionieren:

    const char m_token_begin, m_token_end, m_end;*

    Stattdessen muss es heissen:

    *const char *m_token_begin, *m_token_end, m_end;

    Daher tendiere ich gerade es konsistent wie im zweiten 'Fall' umzusetzen. Also '&' oder '*' an das Objekt, bzw. die Variable zu binden und nicht an den Typ. Wie sind eure Meinungen dazu?

    🙄



  • Tomahawk schrieb:

    ...Daher tendiere ich gerade es konsistent wie im zweiten 'Fall' umzusetzen.

    Ich tendiere unter C++ inzwischen zum 3ten Fall: <Typ> <Zeichen> <Bezeichnung>

    1. Deklariere ich ohnehin niemals mehrere Variablen in einer Zeile.
    2. Spätestens wenn const hinzu kommt gibt es ohnehin wieder Abstände (Zumindest wenn man das const wie ich [Auch wieder nur in C++] immer konsequent hinter das schreibt, was konstant ist).

    Beispiel:

    int const * const wert;
    

    In welche Richtung willst du nun das Zeichen packen?



  • Tomahawk schrieb:

    Daher tendiere ich gerade es konsistent wie im zweiten 'Fall' umzusetzen. Also '&' oder '*' an das Objekt, bzw. die Variable zu binden und nicht an den Typ. Wie sind eure Meinungen dazu?

    Aus genau diesem Grund mache ich das auch so.
    char *s bedeutet nicht "s ist ein char pointer" sondern "der Wert von s (dereferenziert) ist ein char".

    Wo ich gerade bei nutzloser Semantiknerverei bin: In C++ gibt es nur call by value. Call by reference gibts weder in C noch in C++ noch in Java.

    void foo(int *i); //ein Pointer auf ein int wird per value übergeben
    void foo(int &i); //eine Referenz auf ein int wird per value übergeben
    


  • Tomahawk schrieb:

    Wie der Titel schon sagt, eine kleine Stilfrage. Bisher haben wir meist im Stil

    T& a oder char buffer* geschrieben. Allerdings würde folgendes natürlich so nicht funktionieren:

    const char m_token_begin, m_token_end, m_end;*

    Stattdessen muss es heissen:

    *const char *m_token_begin, *m_token_end, m_end;

    Daher tendiere ich gerade es konsistent wie im zweiten 'Fall' umzusetzen. Also '&' oder '*' an das Objekt, bzw. die Variable zu binden und nicht an den Typ. Wie sind eure Meinungen dazu?

    🙄

    Ja, das war die Regel in C.
    Da schrieb man
    int a,b, c[5], *d;
    als erste Zeile und dann gibgs los…

    Ind C++ definiert man eine Variable eigentlich erst, wenn man sie sinnvoll initialisieren kann, und dann bekommt auch jede Variable ihre eigene Zeile. Daher können wir es uns leiten, Typen wie int* oder int& zu denken.



  • Danke für die Meinungen.

    Wahrscheinlich ist es lesbarer für jedes Objekt bzw. jede Variable eine eigene Zeile anzulegen, um genannter Problematik zu entgehen:

    private:
      const char* m_token_begin;
      const char* m_token_end;
      const char* m_end;
    


  • nwp3 schrieb:

    Wo ich gerade bei nutzloser Semantiknerverei bin: In C++ gibt es nur call by value. Call by reference gibts weder in C noch in C++ noch in Java.

    void foo(int *i); //ein Pointer auf ein int wird per value übergeben
    void foo(int &i); //eine Referenz auf ein int wird per value übergeben
    

    😮 Jetzt ist die ganze Welt verwirrt. 😃



  • nwp3 schrieb:

    Wo ich gerade bei nutzloser Semantiknerverei bin: In C++ gibt es nur call by value. Call by reference gibts weder in C noch in C++ noch in Java.

    Nenne es wie du willst, aber bitte verwirre andere nicht damit. Es wird nun einmal in 90+% aller Quellen anders genannt, und die andere Benennung ergibt durchaus Sinn um die Unterschiede zu beschreiben.



  • Ich habe mir die Frage auch schon gestellt und es gibt bei allem irgendwelchen Probleme.
    Letztendlich bin ich aber zu T& a übergegangen, weil das Referenzzeichen ja zum Typ gehört und nicht zum Namen.

    Generell würde ich das aber als Geschmacksfrage beschreiben.



  • Ich bin mittlerweile dazu übergegangen, immer T&/T* zu verwenden, wenn nur eine Variable diesen Typ bekommt (also auch in Parametern, die sind meistens nicht auf einer einzelnen Zeile).

    volkard schrieb:

    Ind C++ definiert man eine Variable eigentlich erst, wenn man sie sinnvoll initialisieren kann

    Es gibt die genannte Ausnahme, wenn man die Membervariablen einer Struktur deklariert:

    private:
      const char *token_begin, *token_end, *end;
    

    Dann mache ich den Stern zum Namen. Allerdings immer nur ein Typ pro Zeile, nie Pointer und Nicht-Pointer gemischt.

    Btw: Ich ziehe "T const&" der Schreibweise "const T&" vor, weil T ist eine const-referenz und T const& ist besser zu lesen (wichtiges zuerst), schreiben und aussprechen.



  • five star programmer schrieb:

    Es gibt die genannte Ausnahme, wenn man die Membervariablen einer Struktur deklariert:

    private:
      const char *token_begin, *token_end, *end;
    

    Dann mache ich den Stern zum Namen. Allerdings immer nur ein Typ pro Zeile, nie Pointer und Nicht-Pointer gemischt.

    Ich mache eine Variable pro Zeile - ist viel besser lesbar. und wenn man einen kommentar zu einer variablen packen will ists auch einfacher dann. oder die commits bei code änderungen an der klasse - ich muss keine zeile mit 10 variablen anpassen und dann funktionieren die blames wieder nicht gut genug. ne ne. 1 zeile pro variable ist besser.

    Btw: Ich ziehe "T const&" der Schreibweise "const T&" vor, weil T ist eine const-referenz und T const& ist besser zu lesen (wichtiges zuerst), schreiben und aussprechen.

    dem stimme ich hingegen voll zu.



  • Tomahawk schrieb:

    private:
      const char* m_token_begin;
      const char* m_token_end;
      const char* m_end;
    

    +1

    Nur dass du das const auf der falschen Seite von char stehen hast 🤡



  • Wenn man mal den Namen weglässt, sieht eine der beiden Varianten unnötig gequetscht aus:

    void (int&, std::string*)
    
    void (int &, std::string *)
    

    Gerade als Template-Argument geht ein kleines & oder ein * unter, wenn kein Leerzeichen davor steht.
    Bei g finde ich die linke Seite durch den langen Typ sehr unübersichtlich. Für das Sternchen am Ende des Typs muss ich zweimal hinsehen. Wenn es jedoch rechts vom Leerzeichen direkt am Namen steht, sehe ich es sofort.

    void g(std::vector<int*>::iterator* it);
    
    void g(std::vector<int *>::iterator *it);
    


  • Gutes Argument, TyRoXx. Stimme dir zu. War mir vorher noch gar nicht so bewusst, das mit dem Auffallen.



  • T *foo
    

    Begründung für mich:

    T* foo, bar;
    static_assert(std::is_same<decltype(foo), decltype(bar)>::value, "Nope");
    

    *, &, && (und bei C++/CLI ^ und 😵 gehören zum Namen, nicht zum Typen.


  • Mod

    TyRoXx schrieb:

    Wenn man mal den Namen weglässt, sieht eine der beiden Varianten unnötig gequetscht aus:

    void (int&, std::string*)
    
    void (int &, std::string *)
    

    Gerade als Template-Argument geht ein kleines & oder ein * unter, wenn kein Leerzeichen davor steht.
    Bei g finde ich die linke Seite durch den langen Typ sehr unübersichtlich. Für das Sternchen am Ende des Typs muss ich zweimal hinsehen. Wenn es jedoch rechts vom Leerzeichen direkt am Namen steht, sehe ich es sofort.

    void g(std::vector<int*>::iterator* it);
    
    void g(std::vector<int *>::iterator *it);
    

    verstehe das Argument nicht

    void g(std::vector<int *>::iterator *it)
    //                   ^ das ist das Templateargument, ein Name folgt nicht
    
    void g(std::vector<int *>::iterator *it)
    //                                   ^  das ist ein Name, aber der Teil davor kein Templateargument
    

    /rant/ schrieb:

    T *foo
    

    Begründung für mich:

    T* foo, bar;
    static_assert(std::is_same<decltype(foo), decltype(bar)>::value, "Nope");
    

    *, &, && (und bei C++/CLI ^ und 😵 gehören zum Namen, nicht zum Typen.

    petitio principii

    ...Und natürlich gehört const vor den Typ (wo möglich), denn das ist die natürliche Reihenfolge in der Sprache (English), aus der diese Wörter stammen.



  • Mit const stimm ich camper zu. Blöd nur, dass das bei Pointern ungedrejt ist.
    Bei mir säh ein Pointer so aus:
    const * const T foo;
    Heißt das was man liest: konstanter Pointer auf konstantes T.
    Was T& angeht, hab ich mich noch nicht entschieden, verwend es mal so, mal so.



  • Typdeklarationen liest man von rechts nach links (und von innen nach außen).

    T const * const foo;
    

    foo ist ein konstanter Zeiger auf ein konstantes T.

    Deshalb schreibe ich es auch so.



  • Nathan schrieb:

    const * const T foo;

    Das ist kein gültiges C++... 😉



  • Nathan schrieb:

    Bei mir säh ein Pointer so aus:

    Die Aussage war doch klar:
    Wenn es nach Nathan ginge, wär's gültig.



  • Danke, dot, aber ich glaub ich weiß wie man Pointer deklariert. 😉
    Man schreibt dazu ein & hinter den Typen.


Log in to reply