int * i; of int * i; of int * i; [gesloten]

Als je schrijft:

int* i, j, k; 

je suggereert misleidend dat alle i, j en k verwijzingen zijn naar int.

Dus ik beweer dat het superieur is om de * aan de variabele te koppelen naam.

Opmerkingen

• En ik ' d stel voor int * i; is alleen een niet-mededinger omdat het er in een oogopslag uitziet als vermenigvuldiging.
• +1 omdat ik ' niet eerder aan dit scenario heb gedacht.
• " je suggereert misleidend dat alle i, j en k verwijzingen zijn naar int. " Tenzij je ' herschrijft C #, waarbij int* wordt gezien als een type, en int* i, j declareert twee verwijzingen. De vraag kan als onvolledig worden beschouwd – het hangt af van de taal die u ' gebruikt welke stijlen redelijk zijn. In CI volg int *x, in C # doe ik anders.
• @Joren: Sorry, omdat ik geen C # programmeur ben, nam ik gewoon aan door naar het codefragment te kijken in de vraag was C of C ++.
• Ik denk dat het volkomen redelijk is om aan te nemen dat het C of C ++ is, tenzij C # specifiek wordt genoemd. Men ziet niet vaak verwijzingen in C #.

Ik geef de voorkeur aan int* i omdat i het type “pointer to an int” heeft, en ik denk dat dit het uniform maakt met het typesysteem. Natuurlijk komt het welbekende gedrag naar voren als ik probeer om meerdere pointers op één regel te definiëren (namelijk de asterisk moet voor elke variabelenaam worden geplaatst om een pointer te declareren), maar ik declareer eenvoudigweg geen pointers op deze manier. Ik denk ook dat het “een ernstig defect is in talen in C-stijl.

Opmerkingen

• Ook ik volg deze conventie. Om dezelfde reden.
• Persoonlijk, als ik ' m meerdere verwijzingen in mijn code declareer, behandel ik het als een codegeur. Ik zou niet ' zoveel aanwijzingen nodig hebben; en meestal doe ik ' t. Dus het probleem van meerdere declaraties op een enkele regel komt nooit voor in een code die ik schrijf: één declaratie per regel.
• Het probleem hiermee is dat het type geen " pointer naar een int ". C (en C ++) heeft geen ' t een aanwijzertype. Het is een verwijzing naar een geheugenblok, waarvan het type int is.
• Ik zou zeggen dat *i een type .
• @Billy: als dat zo is, ' heb ik die verwarring nog nooit gezien in 12 jaar waarin ik probeerde om standaardes te begrijpen, te ontleden en uit te leggen . " Pointer naar een int " is een perfect geldig type in C en C ++.

Voor C, waar we “niet sterk gefocust zijn op typen, geef ik de voorkeur aan:

int *i;

Omdat het een nadruk legt op de int, niet op de pointer. Wat is de int? *i is de int.

Reacties

• Goed punt. Met aanwijzingen kun je beschouw het begin als een onderdeel van de naam. Als u bijvoorbeeld int i = 5 heeft, gebruikt u om de waarde i te krijgen de naam i. Evenzo, als u int *i; *i = 5 heeft, gebruikt u om de waarde te krijgen *i.
• Ik lees int * i als: * i is een int. Daarom is i een pointer naar int.Variabele declaraties in C gebruiken type expressies, int en * zijn slechts operatoren. int * i parseert als int (* (i)) en wordt geïnterpreteerd als i heeft het type pointer-to integer. char * p [] parseert als char (* ([] (p))) (omdat [] een hogere prioriteit heeft dan *) en betekent: p heeft het type array-of pointer-to char.
• Voor daarom denk ik dat ze ervoor kozen om * naast de variabele te schrijven, omdat * een operator is die erop wordt toegepast.
• Ik lijk hier ook de voorkeur aan te geven – houdt de typedefinitie schoner. Bovendien is wat Giorgio schreef ook logisch voor mij en Dennis schreef iets in de trant van zijn redenering.

Ik heb jarenlang de voorkeur gegeven aan int* i. Er is echter een sterk argument voor int *i omdat u bij het gebruik van de vorige stijl nog steeds de regel voor meervoudige declaraties moet onthouden:

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

Omdat je deze regel moet onthouden, krijg je er niet zomaar een – maar ik zou ook niet zeggen dat het complexer is. Het vermijden van meerdere declaraties op één regel is gewoon een andere manier om te zeggen dat je deze regel onthoudt Het verschil tussen de twee stijlen is betwistbaar.

Zelfs als ik het gebruik, voelt het echter een beetje raar om te doen alsof de C-declaratiesyntaxis anders werkt dan het is, door de asterisk naast het type te plaatsen. dan de variabele waaraan het syntactisch is gebonden.

Ik koop die niet in benadrukt het pointer-type (voor i) terwijl de andere het int-type benadrukt (voor *i), maar dat kan zijn dat het na 15 jaar C en C ++ gebruik slechts is als ik ernaar kijk, zonder erover na te hoeven denken⁠ — ⁠someth De meeste beginners die deze vraag stellen kunnen het nog niet doen.

Ook, zelfs gezien mijn voorkeur, vind ik het niet onhandig om code in de andere stijl te lezen / schrijven. Consistentie, bla bla bla.

int * i hoeft niet eens te worden genoemd.

Ik geef de voorkeur aan de eerste. Het komt vanzelfsprekend omdat een pointer deel uitmaakt van het type.

Aangezien ik C # gebruik, behandelt het typen op een meer intuïtieve manier dan C, dus het is geen probleem om verschillende verwijzingen in hetzelfde statement te declareren:

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

Ik geef de voorkeur aan int* i (C ++ – stijl).
Ik vermijd het declareren van meerdere variabelen in één instructie vanwege de resulterende visuele ambiguïteit (int* i, j).

Zie ook Bjarne Stroustrup “s C ++ Style and Technique FAQ voor rationales.

Als u meerdere variabelen wilt declareren maar de asterisk niet wilt herhalen:

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

(Zoals u kunt zien in de struct-sjabloon, Ik geef de voorkeur aan de int* i stijl.)

En hier is een meer algemene oplossing:

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

Deze werkt met elk “problematisch type”, bijvoorbeeld arrays en referenties:

Reacties

• omg, c ++ laat altijd iets nieuws zien :). Bedankt!
• OMG, C ++ is verschrikkelijk! typedef int* int_ptr zou het gelukt zijn. Natuurlijk moet ik een nieuw typedef declareren voor verschillende aanwijzertypen, maar hoeveel zullen dat in de praktijk zijn? Maximaal acht?
• @benzado In de praktijk heb je ' de typedef of een van de leuke trucs die ik heb gedemonstreerd niet nodig, omdat geen gezond persoon meerdere variabelen declareert op één regel. Maar nog steeds interessant.
• Ik weet het, ik sprak meer over de neiging van C ++ -programmas om taalfuncties te gebruiken gewoon omdat ze dat kunnen.
• @benzado: !!! Ik heb dit zo vaak gezien!

Ik “zou gaan voor int* i; aangezien het eerste deel het type variabele aangeeft (pointer naar int), terwijl het tweede deel de naam aangeeft (i). Het zou voor mij niet logisch zijn dat het type is int en de naam is *i. Bovendien lijkt int * i; een beetje op vermenigvuldiging voor mij.

Opmerkingen

• C declaratiesyntaxis isn ' t consistent in dit opzicht, aangezien type-informatie gemakkelijk na de identifier kan komen: arrays is het duidelijkste voorbeeld.
• @Roger: Ik weet het, maar deze vraag was specifiek over een enkele variabele declaratie, en niets anders.
• Ik denk dat ' er een beetje veel in leest. 🙂 Zoals ik de vraag begrijp, wordt er ' gevraagd welke stijl je overal gebruikt.
• @Roger: Jij ' kloppen waarschijnlijk, maar mijn doel was om de OP ' vraag te beantwoorden: " Wat is je favoriete methode om een aanwijzer? ".Het staat natuurlijk iedereen vrij om de kwestie die in de vraag aan de orde wordt gesteld, eens te bekijken, en het wordt hier zelfs aangemoedigd. Als iemand die zich niet ' ontwikkelt in C / C ++, had ik het gevoel dat dit te ver van mijn vakgebied zou afdwalen.

In declaraties gebruik ik int * i;, je leest het als i is a pointer to an integer.

De pointer draagt bij aan zowel het type als de variabele, dus het zou in het midden moeten staan.

Het is een goede zaak om te vermijden dat je meerdere dingen op dezelfde regel declareert: int * i, j;

Er zijn geen typen aanwijzers in C! Dus, “int * “betekent niets. De asterisk is altijd gebonden aan het element dat er rechts van is geschreven, het behoort tot het element er recht op.” * i “is een int. En omdat * i een int is, volgt daaruit dat i een pointer to int. Dat is de logica erachter en daarom is “int * i” de enige mogelijke oplossing. Al het andere is een illusie (die in de meeste gevallen automatisch wordt gecorrigeerd door de compiler). In C ++ en C # is dat iets anders. Maar voor C is er maar één bijbel: “Dennis M. Ritchie: The C Programming Language”. Dennis (RIP!) Schreef het: “int * i”. Het is niet nodig om vraag dit.

Opmerkingen

• " Er zijn geen typen aanwijzers in C " – Waar kwam je op dat idee? int* is een aanwijzertype.

Ik gebruik eigenlijk alle drie de conventies in specifieke omstandigheden. Op het eerste gezicht lijk ik inconsequent, maar …

• int * wanneer de identifier niet aanwezig is, om visueel te versterken dat de naam niet aanwezig is.
• int* intptr op typedef s en soortgelijke verklaringen om visueel te versterken dat het deel uitmaakt van het type. Evenzo met functieaanwijzerverklaringen: (int* (*foo)(int))
• int *identifier en class &identifier op functieparameters om visueel te versterken dat de parameter mogelijk een zogenaamde “out” -parameter is.
• const int * const * const telkens wanneer ik cv gebruik kwalificatiewedstrijden.
• int * foo; op lokale aangiften.

Ik denk dat ik enigszins visueel ingesteld ben.

Ik gebruik int *i omdat het gemakkelijker is om te zien dat het een aanwijzer is Ik denk niet dat het er echt toe doet.