int * i; eller int * i; eller int * i; [stängd]

För C, där vi inte har ett starkt fokus på typer, föredrar jag:

int *i;

Eftersom den har en betoning på int, inte pekaren. Vad är int? *i är int.

Kommentarer

• Bra poäng. Med pekare kan du tänk på starten som en del av namnet. Om du till exempel har int i = 5, för att få värdet av i, använder du namnet i. På samma sätt, om du har int *i; *i = 5, för att få värdet använder du *i.
• Jag läser int * i som: * i är ett int. Därför är jag en pekare till int.Variabla deklarationer i C-typuttryck, int och * är bara operatorer. int * i tolkas som int (* (i)) och tolkas som att jag har typ pekare till heltal. char * p [] tolkas som char (* ([] (p))) (eftersom [] har högre företräde än *) och betyder: p har typ array-av pekare till char.
• För av den anledningen tror jag att de valde att skriva * bredvid variabeln, eftersom * är en operatör som tillämpas på den.
• Jag verkar föredra detta också – håller typdefinitionen renare. Dessutom är det som Giorgio skrev meningsfullt för mig och Dennis skrev något i linje med sitt resonemang.

Jag har föredragit int* i i flera år. Det finns dock ett starkt argument för int *i eftersom du fortfarande måste komma ihåg regeln för flera deklarationer när du använder den tidigare stilen:

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

Eftersom du måste komma ihåg denna regel, vinner du inte något enkelt – men jag skulle inte heller säga att den är mer komplex. Att undvika flera deklarationer på en rad är bara ett annat sätt att säga att du kommer ihåg den här regeln Skillnaden mellan de två stilarna är mycket.

Även när jag använder det känns det dock lite dumt att låtsas att C-deklarationssyntax fungerar annat än vad den gör, genom att placera asterisken bredvid typen snarare än variabeln som den är syntaktiskt bunden till.

Jag köper inte den betonar pekartypen (för i) medan den andra betonar int-typen (för *i), men det kan vara att efter 15 års C- och C ++ -användning är det bara är när jag tittar på det utan att behöva tänka på det⁠ — ⁠someth de flesta nybörjare som ställer den här frågan kan inte göra det ännu.

Även med tanke på mina preferenser tycker jag inte att det är besvärligt att läsa / skriva kod i den andra stilen. Konsistens, bla bla bla.

Du behöver inte ens nämna int * i.

Jag föredrar int* i (C ++ – stil).
Jag undviker att deklarera flera variabler i ett uttalande på grund av den resulterande visuella tvetydigheten (int* i, j).

Se även Bjarne Stroustrup ”s C ++ stil och teknik FAQ för rationaliseringar.

Om du vill deklarera flera variabler men inte vill upprepa asterisken:

template <typename T> struct pointer_to { typedef T* type; }; pointer_to<int>::type p1, p2, p3; 

(Som du kan se inuti strukturen, Jag föredrar int* i -stilen.)

Och här är en mer allmän lösning:

template <typename T> struct identity { typedef T type; }; identity<int*>::type p1, p2, p3; 

Den här fungerar med alla ”problematiska typer”, till exempel matriser och referenser:

Kommentarer

• omg, c ++ visar alltid något nytt för mig :). Tack!
• OMG, C ++ är skrämmande! typedef int* int_ptr skulle ha gjort tricket. Visst, jag måste deklarera en ny typedef för olika pekartyper, men i praktiken hur många kommer det att vara? Åtta som mest?
• @benzado I praktiken behöver du ' t behöver typedef eller något av de snygga knep som jag visat, för ingen sund person förklarar flera variabler i en rad. Fortfarande intressant.
• Jag vet, jag talade mer om C ++ – programmens tendens att använda språkfunktioner bara för att de kan.
• @benzado: !!! Jag har sett det så ofta!

Jag skulle gå för int* i; eftersom den första delen betecknar variabeln (pekaren till int), medan den andra delen betecknar namnet (i). Det skulle inte vara vettigt för mig att typen är int och namnet är *i. Även int * i; ser lite ut som multiplikation för mig.

Kommentarer

• Syntax för C-deklarationen är inte ' t konsekvent i detta avseende, eftersom typinformation lätt kan komma efter identifieraren: arrays är det tydligaste exemplet.
• @Roger: Jag vet, men den här frågan var specifikt om en enda variabeldeklaration och inget annat.
• Jag tror att ' läser lite mycket i den. 🙂 Så som jag förstår frågan är det ' som frågar om vilken stil du använder överallt.
• @Roger: Du ' är nog rätt, men mitt mål var att svara på OP ' s fråga: " Vad är din favoritmetod att förklara en pekare? ".Det är uppenbart att alla har frihet att ta en kostymgranskning av frågan som presenteras i frågan, och det uppmuntras till och med här. Som någon som inte ' utvecklas i C / C ++ kände jag att det skulle avvika för långt från mitt kompetensområde.

I deklarationer använder jag int * i;, du läser det som i is a pointer to an integer.

Pekaren bidrar till både typen och variabeln så den ska vara i mitten.

Det är bra att undvika att förklara flera saker på samma rad: int * i, j;

Det finns inga pekartyper i C! Så, ”int * ”betyder ingenting. Asterisken är alltid bunden till det element som skrivs till höger om det, det tillhör elementet rätt till det.” * i ”är ett int. Och på grund av * i är ett int följer det att jag är en pekare till int. Det är logiken bakom det och det är därför ”int * i” är den enda möjliga lösningen. Allt annat är en illusion (som korrigeras automatiskt av kompilatorn i de flesta fall). I C ++ och C # är det något annat. Men för C finns det bara en bibel: ”Dennis M. Ritchie: The C Programming Language”. Dennis (RIP!) Skrev det: ”int * i”. Det finns inget behov av ifrågasätter detta.

Kommentarer

• " Det finns inga pekartyper i C " – Var fick du den idén? int* är en pekartyp.

Jag använder faktiskt alla tre konventionerna under specifika omständigheter. Vid första anblicken verkar jag inkonsekvent, men …

• int * när identifieraren inte finns, för att visuellt förstärka att namnet inte finns.
• int* intptr på typedef s och liknande deklarationer för att visuellt förstärka att det är en del av typen. På samma sätt med funktionspekardeklarationer: (int* (*foo)(int))
• int *identifier och class &identifier på funktionsparametrar för att visuellt förstärka att parametern potentiellt är en så kallad ”out” -parameter.
• const int * const * const när jag använder cv kvalificeringar.
• int * foo; om lokala deklarationer.

Jag antar att jag är något visuellt orienterad.

Jag använder int *i eftersom det är lättare att se att det är en pekare, dock Jag tycker inte att det verkligen är fråga.