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 siano puntatori a int .

Quindi sostengo che sia superiore ad annettere * al nome della variabile.

Preferisco int* i perché i ha il tipo "puntatore a un int", e ritengo che questo lo renda uniforme con il sistema di tipi. Naturalmente, il comportamento ben noto arriva quando si tenta di definire più puntatori su una riga (vale a dire, l'asterisco deve essere inserito prima di ogni nome di variabile per dichiarare un puntatore), ma semplicemente non dichiarare i puntatori in questo modo. Inoltre, penso che sia un difetto grave nei linguaggi in stile C.

Per C, in cui non ci concentriamo sui tipi, preferisco:

int *i;

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

Preferisco il primo. Viene naturale poiché un puntatore fa parte del tipo.

Poiché utilizzo C #, gestisce i tipi in modo più intuitivo rispetto a C, quindi non ci sono problemi a dichiarare diversi puntatori nella stessa istruzione:

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

Ho preferito int* i per anni. Tuttavia, esiste un argomento valido per int *i perché quando si utilizza lo stile precedente, è comunque necessario ricordare la regola di dichiarazione multipla:

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

Perché devi ricordare questa regola, non ne guadagni in modo esplicito, ma non direi che è 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, è un po 'sciocco fingere che la sintassi della dichiarazione C funzioni diversamente da quella, posizionando l'asterisco accanto al tipo piuttosto che alla variabile a cui è associato sintatticamente.

Non compro in quello enfatizza il tipo di puntatore (per i ) mentre l'altro enfatizza il tipo int (per *i ), ma potrebbe essere che dopo 15 anni di utilizzo di C e C ++, è è quando lo guardo, senza doverlo pensare⁠-⁠ qualcosa che molti principianti che fanno questa domanda non possono ancora fare.

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

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

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 sullo stile e la tecnica C ++ di Bjarne Stroustrup per le ragioni.

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 template struct, preferisco lo stile int* i .)

E qui c'è una soluzione più generale:

template <typename T>
struct identity
{
    typedef T type;
};

identity<int*>::type p1, p2, p3;

Questo funziona con qualsiasi "tipo problematico", per esempio matrici e riferimenti:

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

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

Vorrei andare 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 fosse int e il nome fosse *i . Inoltre, int * i; sembra un po 'come la moltiplicazione per me.

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

Il puntatore contribuisce sia al tipo che alla variabile, quindi dovrebbe trovarsi al centro.

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

Non ci sono tipi di puntatore in C! Quindi "int *" non significa nulla. L'asterisco è sempre legato all'elemento scritto a destra di esso, appartiene all'elemento giusto ad esso. "* i" è un int. E a causa di * i è un int, segue che io sono un puntatore a int. Questa è la logica dietro di esso ed è per questo che "int * i" è l'unica soluzione possibile. Tutto il resto è un'illusione (che viene automaticamente corretta dal compilatore nella maggior parte dei casi). In C ++ e C # è qualcosa di diverso. Ma per C c'è una sola bibbia: "Dennis M. Ritchie: The C Programming Language". Dennis (R.I.P.!) Lo ha scritto: "int * i". Non c'è bisogno di metterlo in discussione.

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

• int * quando l'identificatore non è presente, per rafforzare visivamente che il nome non è presente.
• int* intptr su typedef s e dichiarazioni simili per rafforzare visivamente che fa parte del tipo. Allo stesso modo con le dichiarazioni del puntatore di funzione: (int* (*foo)(int))
• int *identifier e class &identifier sui parametri di funzione per rinforzare visivamente che il parametro è potenzialmente un cosiddetto parametro "out".
• const int * const * const ogni volta che utilizzo i c-v qualificatori.
• int * foo; sulle dichiarazioni locali.

Credo di essere un po 'visivamente orientato.

Uso int *i perché è più facile vedere che si tratta di un puntatore, anche se non penso che sia davvero importante.