it-swarm.it

int * i; o int * i; o int * i;

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

30
lesmana

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.

76
Randall Schulz

Preferisco int* i perché i ha 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 puntatori in questo modo. Inoltre, penso che sia un grave difetto nei linguaggi in stile C.

62
Tamás Szelei

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

int *i;

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

23
alternative

Ho preferito int* i per anni. Tuttavia, esiste 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 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 piuttosto che alla variabile a cui è sintatticamente associato.

Non compro quello enfatizza il tipo di puntatore (per i) mentre l'altro enfatizza il tipo int (per *i), ma può darsi che dopo 15 anni di utilizzo di C e C++, solo sia quando lo guardo, senza doverci pensare it⁠ — qualcosa che la maggior parte dei principianti che pongono 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 menzionare int * i.

7
Roger Pate

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
6
Guffa

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.

5
Archimedix

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 il int* i stile.)

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);
4
fredoverflow

Vorrei 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 int e il nome sia *i. Inoltre, int * i; Assomiglia un po 'alla moltiplicazione.

2
Allon Guralnek

Nelle dichiarazioni utilizzo int * i;, l'hai letto 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;

2
Tamara Wijsman

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* intptr su typedefs 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 uso c-v qualificatori.
  • int * foo; sulle dichiarazioni locali.

Immagino di essere un po 'orientato alla vista.

1
greyfade

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 (R.I.P.!) Lo ha scritto: "int * i". Non è necessario interrogarlo.

1
Lexi Pim