int * i; oder int * i; oder int * i; [geschlossen]

Was ist Ihre Lieblingsmethode, um einen Zeiger zu deklarieren?

int* i;

oder

int *i;

oder

int * i;

oder

int*i;

Bitte erklären Sie warum.

Siehe auch: http://www.stroustrup.com/bs_faq2.html#whitespace

Wenn du schreibst:

int* i, j, k;

Sie schlagen irreführend vor, dass alle i, j und k Zeiger auf sind int.

Ich behaupte, es ist besser, das * an den Variablennamen anzuhängen.

Ich bevorzuge, int* iweil ies den Typ "Zeiger auf ein int" hat, und ich glaube, dies macht es mit dem Typsystem einheitlich. Natürlich tritt das bekannte Verhalten ein, wenn versucht wird, mehrere Zeiger auf einer Zeile zu definieren (das Sternchen muss vor jedem Variablennamen stehen, um einen Zeiger zu deklarieren), aber ich deklariere Zeiger einfach nicht auf diese Weise. Ich denke auch, dass es ein schwerwiegender Fehler in C-Sprachen ist.

Für C, wo wir keinen starken Fokus auf Typen haben, bevorzuge ich:

int *i;

Weil es eine Betonung auf dem hat int, nicht auf dem Zeiger. Was ist das int? *iist die int.

Ich habe int* ijahrelang bevorzugt . Es gibt jedoch ein starkes Argument dafür, int *idass Sie sich bei Verwendung des früheren Stils immer noch an die Mehrfachdeklarationsregel erinnern müssen:

int* a, *b; // not int* a, b;

Weil Sie sich an diese Regel erinnern müssen, gewinnen Sie nicht einfach - aber ich würde auch nicht sagen, dass sie komplexer ist. Das Vermeiden mehrerer Deklarationen in einer Zeile ist nur eine andere Möglichkeit, um zu sagen, dass Sie sich an diese Regel erinnern. Der Unterschied zwischen den beiden Stilen ist umstritten.

Selbst wenn ich es verwende, fühlt es sich ein bisschen albern an, so zu tun, als würde die C-Deklarationssyntax anders funktionieren, als dies der Fall ist, indem das Sternchen neben dem Typ und nicht neben der Variablen platziert wird, an die es syntaktisch gebunden ist.

Ich kaufe nicht in , dass man betont den Zeigertyp (z i) , während die andere den int - Typen (für betont *i), aber das kann sein , dass nach 15 Jahren von C und C ++ verwendet, ist es einfach ist , wenn ich es sehe, ohne darüber nachdenken müssen - etwas, was die meisten Anfänger, die diese Frage stellen, noch nicht können.

Auch wenn ich es vorziehen würde, finde ich es nicht unangenehm, Code in einem anderen Stil zu lesen / schreiben. Beständigkeit, bla bla bla.

Keine Notwendigkeit zu erwähnen int * i.

Ich bevorzuge den ersten. Es ist natürlich, ein Zeiger zu sein, das gehört zum Typ.

Da ich C # verwende, werden Typen intuitiver behandelt als in C, sodass es kein Problem gibt, mehrere Zeiger in derselben Anweisung zu deklarieren:

int* a, b, c; // three pointers

Ich bevorzuge int* i(C ++ - Stil).
Ich vermeide die Deklaration mehrerer Variablen in einer Anweisung aufgrund der daraus resultierenden visuellen Mehrdeutigkeit ( int* i, j).

Weitere Informationen finden Sie in den häufig gestellten Fragen zu C ++ - Stil und Technik von Bjarne Stroustrup .

Wenn Sie mehrere Variablen deklarieren möchten, aber das Sternchen nicht wiederholen möchten:

template <typename T>
struct pointer_to
{
    typedef T* type;
};

pointer_to<int>::type p1, p2, p3;

(Wie Sie in der Strukturvorlage sehen können, bevorzuge ich den int* iStil.)

Und hier ist eine allgemeinere Lösung:

template <typename T>
struct identity
{
    typedef T type;
};

identity<int*>::type p1, p2, p3;

Dieser funktioniert mit jedem "problematischen Typ", zum Beispiel Arrays und Referenzen:

identity<int[10]>::type a1, a2, a3;

identity<int&>::type r1(*p1), r2(*p2), r3(*p3);

Ich würde gehen, int* i;da der erste Teil den Variablentyp (Zeiger auf int) bezeichnet, während der zweite Teil den Namen ( i) bezeichnet. Es würde für mich keinen Sinn ergeben, dass der Typ intund der Name sind *i. Außerdem int * i;sieht ein bisschen wie Multiplikation zu mir.

In Erklärungen, die ich verwende int * i;, liest du es als i is a pointer to an integer.

Der Zeiger trägt sowohl zum Typ als auch zur Variablen bei, sodass er sich in der Mitte befinden sollte.

Es ist eine gute Sache zu vermeiden, mehrere Dinge in derselben Zeile zu deklarieren: int * i, j;

Ich verwende eigentlich alle drei Konventionen unter bestimmten Umständen. Auf den ersten Blick scheine ich inkonsistent, aber ...

• int * Wenn der Bezeichner nicht vorhanden ist, um visuell zu verdeutlichen, dass der Name nicht vorhanden ist.
• int* intptron typedefs und ähnliche Erklärungen, um visuell zu verdeutlichen, dass es sich um einen Teil des Typs handelt. Ähnlich bei Funktionszeigerdeklarationen:(int* (*foo)(int))
• int *identifierund class &identifierauf Funktionsparametern, um visuell zu verdeutlichen, dass der Parameter möglicherweise ein sogenannter "out" -Parameter ist.
• const int * const * constwann immer ich cv qualifier benutze .
• int * foo; auf lokalen Erklärungen.

Ich denke, ich bin etwas visuell orientiert.

In C gibt es keine Zeigertypen! "Int *" bedeutet also nichts. Das Sternchen ist immer an das rechts davon geschriebene Element gebunden, es gehört zu dem rechts davon stehenden Element. "* i" ist ein Int. Und weil * i ein int ist, folgt daraus, dass i ein Zeiger auf int ist. Das ist die Logik dahinter und deshalb ist "int * i" die einzig mögliche Lösung. Alles andere ist eine Illusion (die in den meisten Fällen vom Compiler automatisch korrigiert wird). In C ++ und C # ist das etwas anderes. Aber für C gibt es nur eine Bibel: "Dennis M. Ritchie: Die Programmiersprache C". Dennis (RIP!) Hat es geschrieben: "int * i". Dies muss nicht in Frage gestellt werden.

Ich benutze, int *iweil es einfacher ist zu sehen, dass es ein Zeiger ist, obwohl ich nicht denke, dass es wirklich wichtig ist.