3. Unterschiedliche Zeigernotationen

Unterschiedliche Zeigernotationen

  • L

    asc schrieb:

    Ich mache so etwas durchaus noch, aber ausschließlich in einer for-Schleife:

    for(auto pos=v.begin(), end=v.end(); pos!=end; ++pos)

    Der Unterschied ist der, dass du auch gleich richtig initialisierst! Neben dem dass es in diesem Fall gar nicht anders geht, pos und end so lokal wie nötig (in der Schleife) zu halten.

    0
  • A

    Tja, dacht ich mir, dass das einen Glaubenskrieg auslöst 😃

    Das Beispiel war auch nur da um zu verdeutlichen:
    Ein Pointer ist ein Pointer ist ein Pointer.

    int *ptr;
double *ptr;
myObject *ptr;

    Was ausgegeben wird, wenn man den Inhalt von ptr irgendwohin schreibt, ist immer das gleiche: eine Adresse.
    int, double oder myObject werden durch das '*' nicht modifiziert, also gehört (für mich) der Stern da auch nicht hin.

    Bestes Beispiel, dass der Stern nix mit dem Variablentyp zu tun hat ist, dass du sowas machen kannst:

    void *ptr;

    Derzeit muss ich mich mit Code rumschlagen wo die

    int * a;

    Schreibweise präferiert wird. Ich finde, dass das beim Überfliegen des Codes jedoch zu sehr wie eine Multiplikation aussieht (sprich: man denkt da tut sich was interessantes - dann schaut man doch genauer hin und entdeckt, dass es bloss eine Deklaration ist....nerv).

    Das 'so lokal wie möglich' hab ich inzwischen auch wieder aufgegeben. In wissenschaftlichem Code zerreisst es den Denkfluss. Man hat genug damit zu tun nachzuvollziehen was passiert, ohne durch zwischenzeitliche Variablendeklarationen ausm Konzep gebracht zu werden.

    Und ja: das ist meine, ganz subjektive, Meinung.

    0
  • V

    antialias schrieb:

    Tja, dacht ich mir, dass das einen Glaubenskrieg auslöst 😃
    Das Beispiel war auch nur da um zu verdeutlichen:
    Ein Pointer ist ein Pointer ist ein Pointer.

    int *ptr;
double *ptr;
myObject *ptr;

    Was ausgegeben wird, wenn man den Inhalt von ptr irgendwohin schreibt, ist immer das gleiche: eine Adresse.
    int, double oder myObject werden durch das '*' nicht modifiziert, also gehört (für mich) der Stern da auch nicht hin.

    Und andere meinen, daß bei

    int* pa;

    pa den Typ "Zeiger auf int" hat.
    Und

    typedef int* pint;
pint pa;
    0
  • Mod

    antialias schrieb:

    Das 'so lokal wie möglich' hab ich inzwischen auch wieder aufgegeben. In wissenschaftlichem Code zerreisst es den Denkfluss. Man hat genug damit zu tun nachzuvollziehen was passiert, ohne durch zwischenzeitliche Variablendeklarationen ausm Konzep gebracht zu werden.

    Komisch, ich arbeite auch mit wissenschaftlichem Code und bin genau der gegenteiligen Ansicht.

    Und ja: das ist meine, ganz subjektive, Meinung.

    Na dann. Jeder nach seinem Geschmack. Aber ich erlaube mir, froh darüber zu sein, dass wir nicht gegenseitig unseren Code austauschen 🙂 .

    0
  • A

    Aber ich erlaube mir, froh darüber zu sein, dass wir nicht gegenseitig unseren Code austauschen 🙂 .

    Da sind wir ja wenigstens hier einer Meinung 😃

    0
  • A
     

    typedef int* pint;
pint pa;

    Die typedef liste am Anfang deiner Projekte möcht ich nicht sehen 😃

    typedef int* pint;
typedef float* pfloat;
typedef myClass1* pmyClass1;
typedef myClass2* pmyClass2;
typedef myClass3* pmyClass3;
typedef myClass4* pmyClass4;
.
.
.

    Gerade ausprobiert: vs2008 macht dabei zumindest nichtmal ein highlight bei 'pint'. Das ist noch viel unleserlicher als

    int* p
    0
  • *

    antialias schrieb:

    int, double oder myObject werden durch das '*' nicht modifiziert, also gehört (für mich) der Stern da auch nicht hin.

    Der "*" gehört ganz eindeutig zum Typen und nicht zur Variablen, nur kann man das in C++ nicht wirklich formulieren.

    #include <typeinfo>
#include <iostream>

int main () {
    std::type_info const& ti  = typeid(int);
    std::type_info const& tip = typeid(int*);
    std::type_info const& tlp = typeid(long*);

    std::cout << std::boolalpha;
    std::cout << (tip == tlp) << std::endl;
    std::cout << (ti == tip) << std::endl;
}

    typedefs belegen dies ebenfalls.

    0
  • V

    [quote="~john"]Der "*" gehört ganz eindeutig zum Typen und nicht zur Variablen, nur kann man das in C++ nicht wirklich formulieren./quote]
    Nein.
    Sowohl

    int* pi;

    "pi ist vom Typ Zeiger auf int."
    als auch

    int *pi;

    "Das, wo pi hinzeigt, ist vom Typ int."
    sind sinnvoll, fürchte ich.

    0
  • ?

    ~john schrieb:

    #include <typeinfo>
#include <iostream>

int main () {
    std::type_info const& ti  = typeid(int);
    std::type_info const& tip = typeid(int*);
    std::type_info const& tlp = typeid(long*);

    std::cout << std::boolalpha;
    std::cout << (tip == tlp) << std::endl;
    std::cout << (ti == tip) << std::endl;
}

    Was soll uns das zeigen? 😕

    0
  • A

    volkard hat es auf den Punkt gebracht. Daher auch der Glaubenskrieg:

    Für einige ist es ein Pointer. Punkt. Und das Objekt worauf er zeigt hat halt einen eigenen Typ (int, myObject, oder was auch immer)
    Für andere ist es ein Pointer-auf-int oder ein Pointer-auf-myObject.

    Der Inhalt der Variable ist jedoch immer eine Adresse - erst durch dereferenzieren kommst man an das worauf der Pointer zeigt.

    Letztendlich ist es egal: Da wir uns wohl nie global auf einen Schreibweise einigen werden*. Jeder der nicht nur mit eigenem Code konfrontiert ist kennt alle Schreibweisen. Such dir die aus die für dich logischer ist und bleib dabei.

    *ausser ein zukünftiger C++ Standard verbietet eine der Schreibweisen - was ich mal für extrem unwahrscheinlich halte.

    0
Anmelden zum Antworten