Unterschiedliche Zeigernotationen

antialias

Das ist eine Glaubensfrage ob du

int* a;

oder

int *a;

benutzt

Ich tendiere zu zweiter Variante weil bei ich gewohnt bin soetwas:

double a,b,c,d;

als "4 Variablen vom Typ double" zu lesen.

Wenn du aber sowas schreibst

double* a,b,c,d;

ist a ein Pointer auf einen double während b,c und d einfach nur double Variablen sind (keine Pointer!). Folglich modifiziert das '*' das a und nicht das 'double'.

Um 4 pointer auf einmal zu deklarieren musst du sowas machen:

double *a, *b, *c, *d;

und da fänd ich die Schreibweise

double* a, *b, *c, *d;

unlogisch.

volkard

Da man aber sowas in C++ nicht macht, fällt die Begründung weg.

antialias

Und wieso 'macht man sowas nicht'? Gibts dafür nen triftigen Grund? Oder gar eine göttliche Richtlinie? Oder hast du noch nie

int i,j,k;

in einer Zeile deklariert?

l'abra d'or

antialias schrieb:

Und wieso 'macht man sowas nicht'? Gibts dafür nen triftigen Grund? Oder gar eine göttliche Richtlinie? Oder hast du noch nie
int i,j,k;
in einer Zeile deklariert?

Weil es in C++ nicht notwendig ist, Variablen am Anfang der Funktion zu deklarieren.
Objekte werden deklariert und sofort initialisiert, so eine reihenweise Default-Initialisierung ist einfach nicht nötig.

volkard

antialias schrieb:

Und wieso 'macht man sowas nicht'? Gibts dafür nen triftigen Grund? Oder gar eine göttliche Richtlinie? Oder hast du noch nie
int i,j,k;
in einer Zeile deklariert?

Ja, die Richlinien heißen
- Mach Variablen so lokal wie möglich.
und als ein Aspekt davon
- Versuche die Definition zu verzögern, bis Du eine sinnvolle Initialisierung angeben kannst.

Klar habe ich damals

int i,j,k;

geschrieben, aber das war in C. Und natürlich eine Zeit lang weiter als C++-Neuling.

SeppJ

1. Deklariert man Variablen dort wo man sie braucht und mehrere Variablen vom gleichen Typ braucht man selten an der gleichen Stelle.
2. Initialisiert man dann ja auch gleich die Variablen
3. Und spätestens bei 2. wird es extrem unübersichtlich mehrere Variablen in einer Zeile zu deklarieren
4. Und da man es einheitlich machen will, macht man es halt nirgends, selbst wenn tatsächlich mal der Fall vorkommen würde, wo man zwei oder mehr uninitialiserte Variablen vom gleichen Typ an der gleichen Stelle benötigen würde.

Und 5.: Nein, aus den oben genannten Gründen mache ich nie (oder besser gesagt nicht mehr) int a,b,c;

edit: Zu langsam.

asc

antialias schrieb:

Und wieso 'macht man sowas nicht'?

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

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

Und ansonsten kann ich mich den Vorpostern nur anschließen.

l'abra d'or

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.

antialias

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.

volkard

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;

SeppJ

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 .

antialias

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

Da sind wir ja wenigstens hier einer Meinung

antialias

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

*john 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.

volkard

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

~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?

antialias

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.