it-swarm-eu.dev

int * i; oder int * i; oder int * i;

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

30
lesmana

Wenn Sie schreiben:

int* i, j, k;

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

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

76
Randall Schulz

Ich bevorzuge int* i weil i den Typ "Zeiger auf ein int" hat, und ich denke, dies macht es mit dem Typsystem einheitlich. Natürlich tritt das bekannte Verhalten auf, wenn versucht wird, mehrere Zeiger in einer Zeile zu definieren (dh 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 Sprachen im C-Stil ist.

62
Tamás Szelei

Für C, wo wir uns nicht stark auf Typen konzentrieren, bevorzuge ich:

int *i;

Weil es eine Betonung auf int hat, nicht auf den Zeiger. Was ist das int? *i ist der int.

23
alternative

Ich habe int* i jahrelang. Es gibt jedoch ein starkes Argument für int *i, wenn Sie den früheren Stil verwenden, müssen Sie sich immer noch an die Mehrfachdeklarationsregel erinnern:

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

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

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

Ich kaufe mir diesen nicht ein betont den Zeigertyp (für i), während der andere den int-Typ (für *i), aber das kann sein, dass es nach 15 Jahren C- und C++ - Nutzung nur ist, wenn ich es mir anschaue, ohne darüber nachdenken zu müssen Es ist etwas, was die meisten Anfänger, die diese Frage stellen, noch nicht können.

Auch wenn ich es vorziehe, finde ich es nicht unangenehm, Code im anderen Stil zu lesen/schreiben. Beständigkeit, bla bla bla.

Keine Notwendigkeit, int * i.

7
Roger Pate

Ich bevorzuge den ersten. Es ist natürlich, dass ein Zeiger Teil des Typs ist.

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

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

Ich bevorzuge int* i (C++ - Stil).
Aufgrund der daraus resultierenden visuellen Mehrdeutigkeit vermeide ich es, mehrere Variablen in einer Anweisung zu deklarieren (int* i, j).

Siehe auch Bjarne Stroustrups C++ - FAQ zu Stil und Technik für Rationales.

5
Archimedix

Wenn Sie mehrere Variablen deklarieren möchten, das Sternchen jedoch 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 das int* i Stil.)

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);
4
fredoverflow

Ich würde mich für int* i; Entscheiden, 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 machen, dass der Typ int und der Name *i Ist. Außerdem sieht int * i; Für mich ein bisschen nach Multiplikation aus.

2
Allon Guralnek

In Deklarationen verwende ich int * i;, du liest 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, dass mehrere Dinge in derselben Zeile deklariert werden: int * i, j;

2
Tamara Wijsman

Ich verwende tatsächlich 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* intptr on typedefs und ähnliche Deklarationen, um visuell zu verdeutlichen, dass es Teil des Typs ist. Ähnliches gilt für Funktionszeigerdeklarationen: (int* (*foo)(int))
  • int *identifier und class &identifier on Funktionsparameter, um visuell zu verstärken, dass der Parameter möglicherweise ein sogenannter "out" -Parameter ist.
  • const int * const * const wann immer ich c-v Qualifikatoren benutze.
  • int * foo; auf lokalen Erklärungen.

Ich denke, ich bin etwas visuell orientiert.

1
greyfade

Es gibt keine Zeigertypen in C! "Int *" bedeutet also nichts. Das Sternchen ist immer an das Element gebunden, das rechts davon geschrieben ist, es gehört zu dem Element, das rechts davon steht. "* 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 C-Programmiersprache". Dennis (R.I.P.!) Schrieb es: "int * i". Es besteht keine Notwendigkeit, dies in Frage zu stellen.

1
Lexi Pim