Posizionamento dell'asterisco nelle dichiarazioni del puntatore

Recentemente ho deciso che devo solo imparare finalmente C / C ++, e c'è una cosa che non capisco veramente sui puntatori o più precisamente, la loro definizione.

Che ne dici di questi esempi:

1. int* test;
2. int *test;
3. int * test;
4. int* test,test2;
5. int *test,test2;
6. int * test,test2;

Ora, per quanto ne so, i primi tre casi stanno facendo tutti lo stesso: Test non è un int, ma un puntatore a uno.

La seconda serie di esempi è un po 'più complicata. Nel caso 4, sia test che test2 saranno puntatori a un int, mentre nel caso 5, solo test è un puntatore, mentre test2 è un int "reale". E il caso 6? Come il caso 5?

4, 5 e 6 sono la stessa cosa, solo il test è un puntatore. Se vuoi due puntatori, dovresti usare:

int *test, *test2;

O ancora meglio (per chiarire tutto):

int* test;
int* test2;

Lo spazio bianco attorno agli asterischi non ha alcun significato. Tutti e tre significano la stessa cosa:

int* test;
int *test;
int * test;

" int *var1, var2" È una sintassi malvagia che ha lo scopo di confondere le persone e dovrebbe essere evitata. Si espande a:

int *var1;
int var2;

Molte linee guida di codifica consigliano di dichiarare solo una variabile per riga . Ciò evita qualsiasi confusione del tipo che avevi prima di porre questa domanda. La maggior parte dei programmatori C ++ con cui ho lavorato sembra attenersi a questo.

Un po 'a parte lo so, ma qualcosa che ho trovato utile è leggere le dichiarazioni al contrario.

int* test;   // test is a pointer to an int

Questo inizia a funzionare molto bene, specialmente quando inizi a dichiarare i puntatori const e diventa difficile sapere se è il puntatore che è const, o se è la cosa a cui punta il puntatore che è const.

int* const test; // test is a const pointer to an int

int const * test; // test is a pointer to a const int ... but many people write this as  
const int * test; // test is a pointer to an int that's const

Utilizzare la "Regola spirale in senso orario" per analizzare le dichiarazioni C / C ++;

Ci sono tre semplici passaggi da seguire:

1. Partendo dall'elemento sconosciuto, muoviti in senso spirale / orario; quando si incontrano i seguenti elementi, sostituirli con le corrispondenti istruzioni in inglese:

   [X]oppure []: Array X size of ... o Array undefined size of ...

   (type1, type2): funzione che passa tipo1 e tipo2 restituisce ...

   *: puntatore / i a ...

2. Continua a farlo in una direzione a spirale / in senso orario finché tutti i gettoni non sono stati coperti.
3. Risolvi sempre prima qualsiasi cosa tra parentesi!

Inoltre, le dichiarazioni dovrebbero essere in dichiarazioni separate quando possibile (il che è vero la stragrande maggioranza delle volte).

Come altri menzionati, 4, 5 e 6 sono gli stessi. Spesso le persone usano questi esempi per fare l'argomento che *appartiene alla variabile invece che al tipo. Sebbene sia una questione di stile, si discute se dovresti pensarla e scriverla in questo modo:

int* x; // "x is a pointer to int"

o in questo modo:

int *x; // "*x is an int"

FWIW Sono nel primo campo, ma il motivo per cui altri sostengono la seconda forma è che risolve (principalmente) questo particolare problema:

int* x,y; // "x is a pointer to int, y is an int"

che è potenzialmente fuorviante; invece scriveresti neanche tu

int *x,y; // it's a little clearer what is going on here

o se vuoi davvero due suggerimenti,

int *x, *y; // two pointers

Personalmente, dico di mantenerlo su una variabile per riga, quindi non importa quale stile preferisci.

#include <type_traits>

std::add_pointer<int>::type test, test2;

In 4, 5 e 6, testè sempre un puntatore e test2non è un puntatore. Lo spazio bianco non è (quasi) mai significativo in C ++.

A mio parere, la risposta è ENTRAMBE, a seconda della situazione. In generale, IMO, è meglio mettere l'asterisco accanto al nome del puntatore, piuttosto che il tipo. Confronta ad esempio:

int *pointer1, *pointer2; // Fully consistent, two pointers
int* pointer1, pointer2;  // Inconsistent -- because only the first one is a pointer, the second one is an int variable
// The second case is unexpected, and thus prone to errors

Perché il secondo caso è incoerente? Perché ad esempio int x,y;dichiara due variabili dello stesso tipo ma il tipo è menzionato solo una volta nella dichiarazione. Questo crea un comportamento precedente e previsto. Ed int* pointer1, pointer2;è incoerente con questo perché si dichiara pointer1come un puntatore, ma pointer2è una variabile intera. Chiaramente incline agli errori e, quindi, dovrebbe essere evitato (mettendo l'asterisco accanto al nome del puntatore, piuttosto che il tipo).

Tuttavia , ci sono alcune eccezioni in cui potresti non essere in grado di mettere l'asterisco accanto al nome di un oggetto (e dove è importante dove lo metti) senza ottenere risultati indesiderati, ad esempio:

MyClass *volatile MyObjName

void test (const char *const p) // const value pointed to by a const pointer

Infine, in alcuni casi, potrebbe essere più chiaro mettere l'asterisco accanto al nome del tipo , ad esempio:

void* ClassName::getItemPtr () {return &item;} // Clear at first sight

La logica in C è che dichiari le variabili nel modo in cui le usi. Per esempio

char *a[100];

dice che *a[42]sarà un file char. E a[42]un puntatore di caratteri. E quindia è un array di puntatori di caratteri.

Questo perché gli autori del compilatore originale volevano utilizzare lo stesso parser per espressioni e dichiarazioni. (Non è una ragione molto sensata per una scelta di design della lingua)

Direi che la convenzione iniziale era quella di mettere la stella sul lato del nome del puntatore (lato destro della dichiarazione

• nel linguaggio di programmazione c di Dennis M. Ritchie le stelle sono sul lato destro della dichiarazione.

• guardando il codice sorgente di Linux su https://github.com/torvalds/linux/blob/master/init/main.c possiamo vedere che la stella è anche sul lato destro.

Puoi seguire le stesse regole, ma non è un grosso problema se metti le stelle sul lato del tipo. Ricorda che la coerenza è importante, quindi sempre ma la stella dalla stessa parte indipendentemente da quale lato hai scelto.

Il puntatore è un modificatore del tipo. È meglio leggerli da destra a sinistra per capire meglio come l'asterisco modifica il tipo. 'int *' può essere letto come "puntatore a int '. In più dichiarazioni devi specificare che ogni variabile è un puntatore o verrà creata come variabile standard.

1,2 e 3) Il test è di tipo (int *). Lo spazio bianco non ha importanza.

4,5 e 6) Il test è di tipo (int *). Test2 è di tipo int. Anche in questo caso gli spazi bianchi sono irrilevanti.

Una buona regola pratica, molte persone sembrano afferrare questi concetti: In C ++ molto significato semantico è derivato dall'associazione a sinistra di parole chiave o identificatori.

Prendiamo ad esempio:

int const bla;

La const si applica alla parola "int". Lo stesso vale per gli asterischi dei puntatori, si applicano alla parola chiave a sinistra di essi. E il nome effettivo della variabile? Sì, è dichiarato da ciò che ne resta.