int * i; eller int * i; eller int * i; [lukket]

Hvis du skriver:

int* i, j, k; 

du foreslår misvisende, at alle i, j og k er henvisninger til int.

Så jeg hævder, at det er overlegen at tilføje * til variablen navn.

Kommentarer

• Og jeg ' d foreslår int * i; er kun en ikke-konkurrent, fordi det med et hurtigt blik ligner multiplikation.
• +1 fordi jeg ikke ' t overvejede dette scenario før.
• " du foreslår misvisende, at alle i, j og k er henvisninger til int. " Medmindre du ' omskrivning af C #, hvor int* ses som en type, og int* i, j erklærer to pointer. Spørgsmålet kan betragtes som ufuldstændigt – det afhænger af det sprog, du ' bruger, hvilke stilarter der er rimelige. I CI skal du følge int *x, i C # gør jeg ellers.
• @Joren: Undskyld, fordi jeg ikke er C # -programmerer, antog jeg simpelthen ved at se på kodefragmentet i spørgsmålet var C eller C ++.
• Jeg synes, det er helt rimeligt at antage, at det er C eller C ++, medmindre C # specifikt er nævnt. Man ser ikke markører i C # meget ofte.

Jeg foretrækker int* i fordi i har typen “pointer til en int”, og jeg føler, at det gør det ensartet med typesystemet. Naturligvis kommer den velkendte opførsel ind, når man prøver at definere flere markører på en linje (nemlig stjernen skal placeres foran hvert variabelnavn for at erklære en markør), men jeg erklærer simpelthen ikke markører på denne måde. Jeg synes også, det er en alvorlig mangel på sprog i C-stil.

Kommentarer

• Jeg følger også denne konvention. Af samme grund.
• Personligt, hvis jeg ' erklærer flere markører i min kode, behandler jeg det som en kodelugt. Jeg skulle ikke ' ikke har brug for så mange henvisninger; og som regel ' t. Så spørgsmålet om flere erklæringer på en enkelt linje kommer aldrig op i nogen kode, jeg skriver: En erklæring pr. Linje.
• Problemet med dette er, at typen ikke er en " markør til en int ". C (og C ++) har ikke ' t en markørtype. Det er en markør til en hukommelsesblok, som er type int.
• Jeg vil hævde, at *i har en type int.
• @Billy: I så fald har jeg ' aldrig set den forvirring i 12 år med at forsøge at forstå, analysere og forklare standardiserede . " Markør til en int " er en perfekt gyldig type i C og C ++.

For C, hvor vi ikke har et stærkt fokus på typer, foretrækker jeg:

int *i;

Fordi det har en emfese på int, ikke markøren. Hvad er int? *i er intet.

Kommentarer

• Godt punkt. Med markører kan du tænk på starten som en del af navnet. Hvis du f.eks. har int i = 5, for at få værdien af i, skal du bruge navnet i. Hvis du også har int *i; *i = 5, skal du bruge *i.
• Jeg læser int * i som: * i er en int. Derfor er jeg en markør til int.Variable erklæringer i C-brugstypeudtryk, int og * er kun operatorer. int * i tolkes som int (* (i)) og fortolkes, da jeg har typen pointer-til-heltal. char * p [] tolkes som char (* ([] (p))) (fordi [] har højere prioritet end *) og betyder: p har type array-af pointer-to char.
• For af denne grund tror jeg, de valgte at skrive * ved siden af variablen, fordi * er en operatør, der anvendes til den.
• Jeg synes også at foretrække dette – holder typen definition renere. Plus, hvad Giorgio skrev giver også mening for mig, og Dennis skrev noget i retning af sin ræsonnement.

Jeg har foretrukket int* i i årevis. Der er dog et stærkt argument for int *i fordi når du bruger den tidligere typografi, skal du stadig huske reglen om flere erklæringer:

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

Fordi du skal huske denne regel, vinder du ikke noget simpelt – men jeg vil heller ikke sige, at det er mere kompliceret. At undgå flere erklæringer på en linje er bare en anden måde at sige, at du husker denne regel Forskellen mellem de to stilarter er meget.

Selvom jeg bruger det, føles det dog lidt fjollet at lade som om C-erklæringens syntaks fungerer andet end det gør, ved at placere stjernen ved siden af typen snarere end den variabel, som den er syntaktisk bundet til.

Jeg køber ikke ind i den ene understreger markørtypen (for i), mens den anden understreger int-typen (til *i), men det kan være, at efter 15 års C og C ++ brug er det bare er når jeg ser på det uden at skulle tænke over det – —som ing de fleste begyndere, der stiller dette spørgsmål, kan “ikke gøre det endnu.

Også selvom jeg foretrækker det, finder jeg det ikke akavet at læse / skrive kode i den anden stil. Konsistens, bla bla bla.

Ingen grund til at nævne int * i.

Jeg foretrækker int* i (C ++ – stil).
Jeg undgår at erklære flere variabler i en sætning på grund af den resulterende visuelle tvetydighed (int* i, j).

Se også Bjarne Stroustrup “s C ++ Style og teknik FAQ til rationaliseringer.

Hvis du vil erklære flere variabler, men ikke vil gentage stjernen:

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

(Som du kan se inde i struct-skabelonen, Jeg foretrækker int* i stil.)

Og her er en mere generel løsning:

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

Denne fungerer med enhver “problematisk type”, for eksempel arrays og referencer:

Kommentarer

• omg, c ++ viser altid noget nyt for mig :). Tak!
• OMG, C ++ er skræmmende! typedef int* int_ptr ville have gjort tricket. Sikker på, jeg er nødt til at erklære et nyt typefil til forskellige markørtyper, men i praksis hvor mange vil det være? Otte højst?
• @benzado I praksis behøver du ikke ' behøver ikke typedef eller nogen af de smarte tricks, jeg har demonstreret, fordi ingen sund person erklærer flere variabler i en linje. Stadig interessant.
• Jeg ved, jeg talte mere til C ++ – programmernes tendens til at bruge sprogfunktioner, bare fordi de kan.
• @benzado: !!! Jeg har set dette så ofte!

Jeg ville gå til int* i; da den første del angiver variabeltypen (pointer til int), mens den anden del angiver navnet (i). Det ville ikke give mig mening typen er int og navnet er *i. int * i; ser ligesom multiplikation ud for mig.

Kommentarer

• C-erklæringens syntaks er ikke ' t konsistent i denne henseende, da typeoplysninger let kan komme efter identifikatoren: arrays er det klareste eksempel.
• @Roger: Jeg ved det, men dette spørgsmål var specifikt om en enkelt variabelerklæring og intet andet.
• Jeg tror, at ' læser lidt meget ind i den. 🙂 Den måde, jeg forstår spørgsmålet på, det ' spørger om, hvilken stil du bruger overalt.
• @Roger: Du ' har sandsynligvis ret, men mit mål var at besvare OP ' s spørgsmål: " Hvad er din yndlingsmetode til at erklære en markør? ".Det er åbenbart, at alle har frihed til at tage et boarder-kig på det spørgsmål, der præsenteres i spørgsmålet, og det opfordres endda her. Som en person, der ikke ' ikke udvikler sig i C / C ++, følte jeg, at det ville afvige for langt fra mit ekspertiseområde.

I erklæringer bruger jeg int * i;, du læser det som i is a pointer to an integer.

Markøren bidrager til både typen og variablen, så den skal være i midten.

Det er en god ting at undgå at erklære flere ting på samme linje: int * i, j;

Der er ingen markørtyper i C! Så, “int * “betyder intet. Stjernen er altid bundet til det element, der er skrevet til højre for den, den hører til elementets ret til den.” * i “er en int. Og på grund af * i er en int, følger det, at jeg er en pointer til int. Det er logikken bag det, og det er derfor, at int * i er den eneste mulige løsning. Alt andet er en illusion (som i de fleste tilfælde automatisk korrigeres af compileren). I C ++ og C # er det noget andet. Men for C er der kun en bibel: “Dennis M. Ritchie: C programmeringssprog”. Dennis (RIP!) Skrev det: “int * i”. Der er ingen grund til spørgsmålstegn ved dette.

Kommentarer

• " Der er ingen markørtyper i C " – Hvor fik du den idé? int* er en pegetype.

Jeg bruger faktisk alle tre konventioner under bestemte omstændigheder. Ved første øjekast virker jeg inkonsekvent, men …

• int * når identifikatoren ikke er til stede, for visuelt at forstærke, at navnet ikke er til stede.
• int* intptr på typedef s og lignende erklæringer for visuelt at forstærke, at det er en del af typen. Tilsvarende med funktionsmarkørerklæringer: (int* (*foo)(int))
• int *identifier og class &identifier på funktionsparametre for visuelt at forstærke, at parameteren potentielt er en såkaldt “out” -parameter.
• const int * const * const når jeg bruger cv kvalifikatorer.
• int * foo; om lokale erklæringer.

Jeg tror jeg er noget visuelt orienteret.

Jeg bruger int *i fordi det er nemmere at se, at det er en markør, dog Jeg synes ikke, det er virkelig noget.