int * i; vagy int * i; vagy int * i; [zárt]

Ha ezt írja:

int* i, j, k; 

megtévesztően azt sugallja, hogy i, j és k mindegyike a int mutatóra mutat.

Tehát állítom, hogy a * -ot a változóhoz kell csatolni. név.

Megjegyzések

• És ' javaslom int * i; csak azért nem versenyző, mert gyors pillantásra szorzásnak tűnik.
• +1, mert korábban nem vettem figyelembe ' ezt a forgatókönyvet.
• " megtévesztően azt sugallja, hogy i, j és k mindegyike int-re mutat. " Kivéve, ha ' a C # újraírása, ahol a int* típusnak tekinthető, az int* i, j pedig két mutatót deklarál. A kérdés hiányosnak tekinthető – attól függ, hogy ' milyen nyelvet használ, mely stílusok ésszerűek. A CI-ben kövesse a következőt: int *x, a C # -ben másképp.
• @Joren: Sajnálom, hogy nem vagyok C # programozó, egyszerűen azt feltételeztem, hogy megnéztem a a kérdés C vagy C ++ volt.
• Úgy gondolom, hogy teljesen ésszerű feltételezni, hogy a C vagy C ++, hacsak nem külön említik a C # -t. Az ember nem nagyon lát mutatókat a C # számban.

Inkább int* i mert a i típusa “point to to int”, és úgy érzem, hogy ez egységessé teszi a típusrendszerrel. Természetesen bejön a jól ismert viselkedés, amikor több mutatót próbál meg definiálni egy sorban (nevezetesen, a csillagot minden változó neve elé kell tenni, hogy kijelentsük a mutatót), de egyszerűen nem deklarálom a mutatókat így. Ezenkívül úgy gondolom, hogy ez a C-stílusú nyelvek súlyos hibája.

Megjegyzések

• Én is követem ezt az egyezményt. Ugyanezen okból.
• Személy szerint, ha ' több mutatót deklarálok a kódomban, akkor azt kódszagként kezelem. Nem kellene ' szükségem ennyi mutatóra; és általában nem ' t. Tehát egyetlen sorban többszörös deklaráció kérdése soha nem merül fel az általam írt kódokban: Soronként egy deklaráció.
• Ezzel az a probléma, hogy a típus nem egy " mutató egy int " mutatóra. C (és C ++) nem rendelkezik ' t mutatótípussal. Mutató egy blokkra, amely int típusú.
• Azt állítom, hogy a *i típusa int.
• @Billy: Ha igen, akkor ' még soha nem láttam ezt a zavart 12 év alatt, amikor megpróbáltam megérteni, értelmezni és megmagyarázni a szabványokat . A " egy int " mutatója tökéletesen érvényes típus C és C ++ nyelven.

A C esetében, ahol nem nagyon foglalkozunk a típusokkal, inkább:

int *i;

Mivel a int -ben hangsúlyozott, és nem a mutatóban. Mi az a int? *i az int.

Megjegyzések

• Jó pont. Mutatókkal megadhatja úgy gondolja, hogy a start része a név részének. Ha például van int i = 5, akkor a i értékének megadásához használja a a i név. Hasonlóképpen, ha van int *i; *i = 5, akkor az érték megszerzéséhez használja a *i.
• Az int * i-t így olvasom: * i egy int. Ezért i az int mutatója.A változó deklarációk a C típusú típusú kifejezésekben, az int és * csak operátorok. Az int * i elemzi az int (* (i)) elemet, és úgy értelmezzük, hogy i típusú egérrel rendelkezik. A char * p [] char-ként értelmezi (* ([] (p))) (mert a [] nagyobb elsőbbséggel rendelkezik, mint a *), és azt jelenti: p típusú tömb-pointer-to char.
• emiatt úgy gondolom, hogy a * mellett írtak a változó mellett, mert a * operátor alkalmazzák rá.
• Úgy tűnik, ezt is jobban kedvelem – tisztábban tartja a típusdefiníciót. Ráadásul nekem is van értelme annak, amit Giorgio írt, és Dennis okfejtéseiben írt valamit.

Évek óta a int* i -t részesítem előnyben. Erős érv szól azonban a int *i mellett, mert az előbbi stílus használatakor még mindig emlékeznie kell a többszörös deklarációs szabályra:

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

Mivel emlékeznie kell erre a szabályra, egyszerűen nem nyer semmit – de én sem mondanám bonyolultabbnak. A többszörös deklarációk elkerülése egy soron csak egy másik módja annak, hogy emlékezzen erre a szabályra . A két stílus közötti különbség vitatott.

Még akkor is, ha használom, kissé ostobaság úgy tenni, mintha a C deklaráció szintaxisa másképp működne, mint amilyen, ha a csillagot a típus mellé helyezzük mint a szintaktikailag kötött változó.

Nem veszek bele egy hangsúlyozza a mutatótípust (a i), míg a másik az int típust hangsúlyozza (*i esetén), de lehet, hogy 15 év C és C ++ használat után csak is ha ránézek, anélkül, hogy gondolkodnom kellene rajta – valamivel A legtöbb kezdő, aki felteszi ezt a kérdést, még nem teheti meg.

Továbbá, még ha preferálnám is, nem találom kínosnak a másik stílusú kódolvasást / -írást. Összhang, bla bla blah.

Nem is kell megemlíteni a int * i -t.

Inkább a int* i (C ++ – stílus).
Kerülöm az egy utasításban több változó deklarálását az ebből adódó vizuális kétértelműség miatt (int* i, j).

Lásd még Bjarne Stroustrup C ++ stílus- és technika-GYIK az ésszerűség érdekében.

Ha több változót akar deklarálni, de nem akarja megismételni a csillagot:

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

(Amint a struktúrasablon belsejében láthatja, Jobban szeretem a int* i stílust.)

És itt van egy általánosabb megoldás:

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

Ez bármilyen “problémás típussal” működik, például tömbökkel és hivatkozásokkal:

Megjegyzések

• omg, c ++ mindig valami újat mutat nekem :). Köszönöm!
• OMG, C ++ borzalmas! typedef int* int_ptr megtette volna a trükköt. Persze, be kell jelentenem egy új typefet a különböző mutatótípusokhoz, de a gyakorlatban ez hány lesz? Legfeljebb nyolc?
• @benzado A gyakorlatban nincs szükséged ' neked a typedefre vagy az általam bemutatott divatos trükkökre, mert egyetlen épeszű ember sem deklarál több változót egy sorban. Mégis érdekes, mégis.
• Tudom, hogy inkább a C ++ programok tendenciájáról beszéltem, hogy csak azért használják a nyelvi funkciókat, mert képesek rá.
• @benzado: !!! Olyan gyakran láttam ezt!

int* i; mivel az első rész a változó típust jelöli (point to to int), míg a második rész a nevet (i). Számomra nem lenne értelme a típus int, a név pedig *i. Ezenkívül a int * i; nekem egy kicsit szorzásnak tűnik.

Megjegyzések

• A C deklaráció szintaxisa nem ' ebben a tekintetben nem következetes, mivel a típusinformációk könnyen jöhetnek az azonosító után: a legtisztább példa a tömbök.
• @Roger: Tudom, de ez a kérdés konkrétan egyetlen változó deklarációról, és semmi másról.
• Úgy gondolom, hogy ' kicsit sokat olvas benne. 🙂 Ahogy megértem a kérdést, ' azt kérdezi, hogy melyik stílust használja mindenhol.
• @Roger: Te ' nek valószínűleg igaza van, de az volt a célom, hogy megválaszoljam az OP ' kérdést: " Mi a kedvenc módszered kijelenteni egy mutató? ".Nyilvánvaló, hogy mindenki szabadon megnézheti a kérdésben bemutatott kérdést, és itt még ösztönzik is. Amikor valaki, aki nem ' fejlődik C / C ++ nyelven, úgy éreztem, hogy ezzel túl messzire téved a szakterületemtől.

Az általam használt int * i; deklarációkban i is a pointer to an integer.

A mutató mind a típushoz, mind a változóhoz hozzájárul, így középen kell lennie.

Jó dolog elkerülni, hogy több dolgot deklaráljanak ugyanazon a soron: int * i, j;

A C-ben nincsenek mutatótípusok! Tehát, “int A * “nem jelent semmit. A csillag mindig az ahhoz írt elemhez van kötve, a hozzá tartozó elemhez tartozik.” * i “egy int. És * i miatt egy int következik, hogy i egy mutató az int-re. Ez a logika áll mögötte, és ezért az “int * i” az egyetlen lehetséges megoldás. Minden más illúzió (amelyet a fordító a legtöbb esetben automatikusan korrigál). A C ++ és C # nyelvekben ez valami más. De C esetében csak egy biblia létezik: “Dennis M. Ritchie: A C programozási nyelv”. Dennis (RIP!) Ezt írta: “int * i”. Nincs szükség kérdőjelezd meg ezt.

Megjegyzések

• " A C " – Honnan vette ezt az ötletet? int* egy mutatótípus.

Valójában mindhárom konvenciót bizonyos körülmények között használom. Első pillantásra következetlennek tűnik, de …

• int * amikor az azonosító nincs megadva, annak vizuális megerősítésére, hogy a név nincs.
• int* intptr typedef s és hasonló deklarációkon, hogy vizuálisan megerősítsék, hogy ez a típus része. Hasonlóan a függvénymutató deklarációkhoz: (int* (*foo)(int))
• int *identifier és class &identifier a függvényparamétereken annak vizuális megerősítésére, hogy a paraméter potenciálisan egy úgynevezett “out” paraméter.
• const int * const * const, amikor a cv t használom selejtezők.
• int * foo; a helyi nyilatkozatokról.

Gondolom, kissé vizuálisan vagyok orientálva.

Azért használom a int *i -et, mert könnyebb belátni, hogy ez mutató Nem hiszem, hogy ez igazán számít.