Răspuns
Dacă scrieți:
int* i, j, k;
sugerați în mod înșelător că toți i, j și k sunt indicatori pentru int.
Prin urmare, susțin că este superioară anexarea * la variabilă nume.
Comentarii
Răspuns
Prefer int* i deoarece i are tipul „pointer to a int” și consider că acest lucru îl face uniform cu sistemul de tip. Desigur, comportamentul bine-cunoscut vine, atunci când încercăm să definim mai mulți indicatori pe o singură linie (și anume, asteriscul trebuie pus înaintea fiecărui nume de variabilă pentru a declara un pointer), dar pur și simplu nu declar indicii în acest fel. De asemenea, cred că este un defect grav în limbajele în stil C.
Comentarii
Răspuns
Pentru C, unde nu ne concentrăm puternic pe tipuri, prefer:
int *i;
Deoarece are o emfază pe int, nu pe indicator. Ce este int? *i este int.
Comentarii
Răspuns
Am preferat int* i de ani de zile. Cu toate acestea, există un argument puternic pentru int *i deoarece atunci când utilizați stilul anterior, trebuie totuși să vă amintiți regula declarației multiple:
int* a, *b; // not int* a, b;
Deoarece trebuie să vă amintiți această regulă, nu obțineți nici o simplitate – dar nici nu aș spune că este mai complexă. Evitarea declarațiilor multiple pe o singură linie este doar un alt mod de a spune că vă amintiți această regulă . Diferența dintre cele două stiluri este discutabilă.
Chiar și în timp ce îl folosesc, totuși este puțin prostesc să pretind că sintaxa declarației C funcționează altfel decât o face, plasând asteriscul lângă tip decât variabila de care este legată sintactic.
Nu cumpăr acea subliniază tipul indicatorului (pentru i) în timp ce cealaltă subliniază tipul int (pentru *i), dar poate că după 15 ani de utilizare a C și C ++, este doar is când mă uit la el, fără a fi nevoie să mă gândesc la asta – ceva Dacă majoritatea începătorilor care pun această întrebare nu pot face încă.
De asemenea, chiar și având în vedere preferința mea, nu mi se pare incomod să citesc / scriu cod în celălalt stil. Coerență, bla bla bla.
Nu este nevoie să menționezi nici măcar int * i.
Răspuns
Îl prefer pe primul. Este firesc, deoarece faptul că este un pointer face parte din tip.
Pe măsură ce folosesc C #, gestionează tipurile într-un mod mai intuitiv decât C, deci nu există nicio problemă în declararea mai multor indicatori în aceeași declarație:
int* a, b, c; // three pointers
Răspuns
Răspuns
Dacă doriți să declarați mai multe variabile, dar nu doriți să repetați asteriscul:
template <typename T> struct pointer_to { typedef T* type; }; pointer_to<int>::type p1, p2, p3;
(După cum puteți vedea în șablonul struct, Prefer stilul int* i.)
Iată o soluție mai generală:
template <typename T> struct identity { typedef T type; }; identity<int*>::type p1, p2, p3;
Acesta funcționează cu orice „tip problematic”, de exemplu tablouri și referințe:
Comentarii
Răspuns
Aș alege int* i; deoarece prima parte denotă tipul variabilei (pointer to int), în timp ce a doua parte denotă numele (i). Nu ar avea sens pentru mine că tipul este int, iar numele este *i. De asemenea, int * i; mi se pare cam multiplicare.
Comentarii
Răspuns
În declarațiile pe care le folosesc int * i;, îl citiți ca i is a pointer to an integer.
Pointerul contribuie atât la tip, cât și la variabilă, așa că ar trebui să fie la mijloc.
Este „un lucru bun să evitați declararea mai multor lucruri pe aceeași linie: int * i, j;
Răspuns
Nu există tipuri de pointer în C! Deci, „int * „nu înseamnă nimic. Asteriscul este întotdeauna legat de elementul scris din dreptul său, aparține elementului din dreptul acestuia.” * i „este un int. Și din cauza * i este un int, rezultă că i este un pointer to int. Aceasta este logica din spatele ei și de aceea „int * i” este singura soluție posibilă. Orice altceva este o iluzie (care este corectată automat de compilator în majoritatea cazurilor). În C ++ și C # este ceva diferit. Dar pentru C există o singură Biblie: „Dennis M. Ritchie: Limbajul de programare C”. Dennis (RIP!) A scris-o: „int * i”. Nu este nevoie să puneți la îndoială acest lucru.
Comentarii
Răspuns
De fapt, folosesc toate cele trei convenții în circumstanțe specifice. La prima vedere par inconsistent, dar …
-
int * atunci când identificatorul nu este prezent, pentru a consolida vizual faptul că numele nu este prezent.
-
int* intptr pe typedef s și declarații similare pentru a consolida vizual faptul că face parte din tip. În mod similar, cu declarațiile indicatorului funcțional: (int* (*foo)(int))
-
int *identifier și class &identifier pe parametrii funcției pentru a consolida vizual faptul că parametrul este potențial un așa-numit parametru „out”.
-
const int * const * const ori de câte ori folosesc cv calificative.
-
int * foo; privind declarațiile locale.
Cred că sunt oarecum orientat vizual.
Răspuns
Folosesc int *i deoarece este mai ușor să vezi că este un pointer, totuși Nu cred că este cu adevărat important.