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

Qual è il tuo metodo preferito per dichiarare un puntatore?

int* i;

o

int *i;

o

int * i;

o

int*i;

Per favore, spiega perché.

vedi anche: http://www.stroustrup.com/bs_faq2.html#whitespace

Se scrivi:

int* i, j, k;

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

Quindi sostengo che sia superiore allegare * al nome della variabile.

Preferisco int* iperché iha il tipo "pointer to a int", e penso che questo lo renda uniforme con il sistema dei tipi. Naturalmente, il comportamento ben noto arriva quando si cerca di definire più puntatori su una riga (vale a dire, l'asterisco deve essere messo prima di ogni nome di 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.

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

int *i;

Perché ha un'enfesi sul int, non sul puntatore. Qual è il int? *iè l'int.

Ho preferito int* iper anni. Tuttavia, esiste un argomento forte int *iperché, 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 che è anche più complesso. Evitare dichiarazioni multiple 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 far finta che la sintassi della dichiarazione C funzioni diversamente da quella, posizionando l'asterisco accanto al tipo anziché alla variabile a cui è sintatticamente associato.

Io non comprare in quella enfatizza il tipo di puntatore (per i), mentre l'altro sottolinea il tipo int (per *i), ma che può essere che dopo 15 anni di utilizzo C e C ++, semplicemente è quando la guardo, senza dovendoci pensare⁠ —⁠qualcosa che la maggior parte dei principianti che pone questa domanda non può ancora fare.

Inoltre, nonostante le mie preferenze, non trovo imbarazzante leggere / scrivere codice nell'altro stile. Coerenza, bla bla blah.

Non c'è nemmeno bisogno di menzionarlo int * i.

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

Mentre uso C #, gestisce i tipi in un modo più intuitivo di 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 un'istruzione a causa dell'ambiguità 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 l'asterisco:

template <typename T>
struct pointer_to
{
    typedef T* type;
};

pointer_to<int>::type p1, p2, p3;

(Come puoi vedere all'interno del modello struct, preferisco lo int* istile.)

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 matrici e riferimenti:

identity<int[10]>::type a1, a2, a3;

identity<int&>::type r1(*p1), r2(*p2), r3(*p3);

Vorrei per int* i;poiché la prima parte indica il tipo di variabile (puntatore a int), mentre la seconda parte indica il nome ( i). Non avrebbe senso per me che il tipo sia inte il nome sia *i. Inoltre, mi int * i;sembra un po 'una moltiplicazione.

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;

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

• int * quando l'identificatore non è presente, per rinforzare visivamente che il nome non è presente.
• int* intptrsu typedefdichiarazioni simili per rafforzare visivamente che fa parte del tipo. Allo stesso modo con le dichiarazioni del puntatore a funzione:(int* (*foo)(int))
• int *identifiere class &identifiersui parametri di funzione per rafforzare visivamente che il parametro è potenzialmente un cosiddetto parametro "out".
• const int * const * constogni volta che uso qualificatori CV .
• int * foo; sulle dichiarazioni locali.

Immagino di essere un po 'orientato alla vista.

Non ci sono tipi di puntatori in C! Quindi, "int *" non significa nulla. L'asterisco è sempre associato all'elemento scritto a destra, appartiene all'elemento proprio ad esso. "* i" è un int. E a causa di * i è un int, ne consegue che i è un puntatore a int. Questa è la logica che sta dietro ed è per questo che "int * i" è l'unica soluzione possibile. Tutto il resto è un'illusione (che viene corretta automaticamente dal compilatore nella maggior parte dei casi). In C ++ e C # è 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 interrogarlo.

Lo uso int *iperché è più facile vedere che si tratta di un puntatore, anche se non penso che sia davvero questione.