int * i; o int * i; o int * i; [chiuso]

Se scrivi:

int* i, j, k; 

suggerisci in modo fuorviante che tutti i, j e k sono puntatori a int.

Quindi sostengo che sia superiore allegare * alla variabile nome.

Commenti

• E io ' d suggerisco int * i; non è un concorrente solo perché a prima vista sembra una moltiplicazione.
• +1 perché ' non avevo considerato questo scenario prima.
• " suggerisci in modo fuorviante che tutti i, j e k sono puntatori a int. " A meno che tu non ' sta scrivendo C #, dove int* è visto come un tipo e int* i, j dichiara due puntatori. La domanda potrebbe essere considerata incompleta – dipende dalla lingua che ' stai utilizzando quali stili sono ragionevoli. In CI segui int *x, in C # faccio diversamente.
• @Joren: Scusa, non essendo un programmatore C #, ho semplicemente assunto guardando il frammento di codice in la domanda era C o C ++.
• Penso che sia perfettamente ragionevole presumere che sia C o C ++ a meno che C # non sia specificamente menzionato. Non si vedono molto spesso i puntatori in C #.

Preferisco int* i perché i ha il tipo “pointer to an int”, e ritengo che questo lo renda uniforme con il sistema dei tipi. Ovviamente, il comportamento ben noto entra in gioco quando si cerca di definire più puntatori su una riga (vale a dire, lasterisco deve essere messo prima del nome di ogni variabile per dichiarare un puntatore), ma semplicemente non dichiaro i puntatori in questo modo. Inoltre, penso che sia “un grave difetto nei linguaggi in stile C.

Commenti

• Anchio seguo questa convenzione. Per lo stesso motivo.
• Personalmente, se ' dichiaro più puntatori nel mio codice, lo tratto come un odore di codice. Non dovrei ' bisogno di tanti puntatori; e di solito non ' t. Quindi il problema di più dichiarazioni su una singola riga non emerge mai in nessun codice che scrivo: una dichiarazione per riga.
• Il problema con questo è che il tipo non è un " puntatore a un int ". C (e C ++) ' non hanno un tipo di puntatore. È un puntatore a un blocco di memoria, di cui è di tipo int.
• Direi che *i ha un tipo di int.
• @Billy: Se è così, ' non ho mai visto quella confusione in 12 anni di tentativi di comprendere, analizzare e spiegare gli standard . " Pointer to an int " è un tipo perfettamente valido in C e C ++.

Per C, dove “non ci concentriamo molto sui tipi, preferisco:

int *i;

Perché ha unenfesi su int, non sul puntatore. Che cosè int? *i è lint.

Commenti

• Buona osservazione. Con i puntatori puoi pensa allinizio come parte del nome. Ad esempio, se hai int i = 5, per ottenere il valore di i, utilizzi il nome i. Allo stesso modo, se hai int *i; *i = 5, per ottenere il valore, utilizza *i.
• Ho letto int * i come: * i è un int, quindi i è un puntatore a int.Le dichiarazioni di variabili in C utilizzano espressioni di tipo, int e * sono solo operatori. int * i analizza come int (* (i)) e viene interpretato come i ha un tipo pointer-to integer. char * p [] analizza come char (* ([] (p))) (perché [] ha una precedenza maggiore di *) e significa: p ha tipo array-of pointer-to char.
• Per per questo motivo penso che abbiano scelto di scrivere * accanto alla variabile, perché * è un operatore applicato ad essa.
• Mi sembra di preferire anche questo – mantiene la definizione del tipo più pulita. Inoltre, ciò che ha scritto Giorgio ha senso anche per me e Dennis ha scritto qualcosa in linea con il suo ragionamento.

Ho preferito int* i da anni. Tuttavia, cè un argomento forte per int *i perché quando si utilizza lo stile precedente, è comunque necessario ricordare la regola delle dichiarazioni multiple:

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

Poiché devi ricordare questa regola, non ne guadagni in modo semplice, ma non direi nemmeno che è più complessa. Evitare più dichiarazioni su una riga è solo un altro modo per dire che ricordi questa regola . La differenza tra i due stili è discutibile.

Anche se lo uso, tuttavia, sembra un po sciocco fingere che la sintassi della dichiarazione C funzioni diversamente, posizionando lasterisco accanto al tipo piuttosto rispetto alla variabile a cui è sintatticamente legato.

Non ci credo enfatizza il tipo di puntatore (per i) mentre laltro enfatizza il tipo int (per *i), ma potrebbe essere che dopo 15 anni di utilizzo di C e C ++, è solo è quando lo guardo, senza doverci pensare⁠ — ⁠qualcosa La maggior parte dei principianti che fanno questa domanda non può ancora farlo.

Inoltre, anche data la mia preferenza, non trovo scomodo leggere / scrivere codice nellaltro stile. Coerenza, bla bla blah.

Non cè nemmeno bisogno di menzionare int * i.

Preferisco il primo. Viene naturale in quanto essere un puntatore fa parte del tipo.

Poiché uso C #, gestisce i tipi in un modo più intuitivo rispetto al C, quindi non cè problema a dichiarare più puntatori nella stessa istruzione:

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

Preferisco int* i (stile C ++).
Evito di dichiarare più variabili in ununica istruzione a causa dellambiguità visiva risultante (int* i, j).

Vedi anche Domande frequenti su stile e tecnica C ++ di Bjarne Stroustrup per motivi razionali.

Se vuoi dichiarare più variabili ma non vuoi ripetere lasterisco:

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

(Come puoi vedere allinterno del modello struct, Preferisco lo stile int* i.)

Ed ecco una soluzione più generale:

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

Questo funziona con qualsiasi “tipo problematico”, ad esempio array e riferimenti:

Commenti

• omg, c ++ mi mostra sempre qualcosa di nuovo :). Grazie!
• OMG, C ++ è orribile! typedef int* int_ptr avrebbe funzionato. Certo, devo dichiarare un nuovo typedef per diversi tipi di puntatore, ma in pratica quanti saranno? Otto al massimo?
• @benzado In pratica, ' non ti serve il typedef o uno dei trucchi che ho dimostrato, perché nessuna persona sana di mente dichiara più variabili in una riga. Ancora interessante, però.
• Lo so, stavo parlando più della tendenza dei programmi C ++ a utilizzare le funzionalità del linguaggio solo perché possono.
• @benzado: !!! Lho visto così spesso!

Preferisco int* i; poiché la prima parte denota il tipo di variabile (puntatore a int), mentre la seconda parte denota il nome (i). “Non avrebbe senso che il tipo è int e il nome è *i. Inoltre, int * i; mi sembra un po come una moltiplicazione.

Commenti

• La sintassi della dichiarazione C non è ' t coerente a questo proposito, poiché le informazioni sul tipo possono facilmente venire dopo lidentificatore: gli array sono lesempio più chiaro.
• @Roger: Lo so, ma questa domanda era specificamente su una singola dichiarazione di variabile, e nientaltro.
• Penso che ' stia leggendo un po troppo in essa. 🙂 Per come intendo la domanda, ' ti chiede quale stile usi ovunque.
• @Roger: You ' probabilmente hai ragione, ma il mio scopo era rispondere alla ' domanda dellOP: " Qual è il tuo metodo preferito per dichiarare un puntatore? ".Ovviamente, tutti sono liberi di dare uno sguardo al limite al problema presentato nella domanda, ed è persino incoraggiato qui. Come qualcuno che non ' t sviluppa in C / C ++, ho sentito che farlo si sarebbe allontanato troppo dal mio campo di competenza.

Nelle dichiarazioni che uso int * i;, lo leggi come i is a pointer to an integer.

Il puntatore contribuisce sia al tipo che alla variabile, quindi dovrebbe essere nel mezzo.

È una buona cosa evitare di dichiarare più cose sulla stessa riga: int * i, j;

Non ci sono tipi di puntatore in C! Quindi, “int * “non significa niente. Lasterisco è sempre legato allelemento scritto a destra di esso, appartiene allelemento proprio ad esso.” * i “è un int. E poiché * i è un int, ne consegue che i è un puntatore a int. Questa è la logica che sta dietro ed è per questo che “int * i” è lunica soluzione possibile. Tutto il resto è unillusione (che nella maggior parte dei casi viene corretta automaticamente dal compilatore). In C ++ e C # questo è qualcosa di diverso. Ma per C cè solo una bibbia: “Dennis M. Ritchie: The C Programming Language”. Dennis (RIP!) Lo ha scritto: “int * i”. Non è necessario domanda questo.

Commenti

• " Non ci sono tipi di puntatore in C " – Dove ti è venuta lidea? int* è un tipo di puntatore.

In realtà uso tutte e tre le convenzioni in circostanze specifiche. A prima vista sembro incoerente, ma …

• int * quando lidentificatore non è presente, per rinforzare visivamente che il nome non è presente.
• int* intptr su typedef e dichiarazioni simili per rafforzare visivamente che fa parte del tipo. Allo stesso modo con le dichiarazioni del puntatore a funzione: (int* (*foo)(int))
• int *identifier e class &identifier sui parametri della funzione per rafforzare visivamente che il parametro è potenzialmente un cosiddetto parametro “out”.
• const int * const * const ogni volta che utilizzo cv qualificatori.
• int * foo; sulle dichiarazioni locali.

Immagino di essere in qualche modo orientato alla visualizzazione.

Uso int *i perché è più facile vedere che si tratta di un puntatore, però Non credo che sia davvero importante.