Sintassi del puntatore in C: perché * si applica solo alla prima variabile?

Question

La seguente dichiarazione in C:

int* a, b; 

dichiareremo a come tipo int* e b come tipo int. Sono ben consapevole di questa trappola, ma quello che voglio sapere è perché funziona in questo modo. Perché non dichiara anche int* come , come la maggior parte delle persone si aspetterebbe intuitivamente? In altre parole, perché * si applica al nome della variabile, piuttosto che al tipo?

Certo si potrebbe scrivere in questo modo di essere più coerente di come è in realtà opere:

int *a, b; 

Tuttavia, io e tutti quelli che ho parlato a pensare in termini di una è di tipo " puntatore a int ", anziché a è un puntatore ad alcuni dati e il tipo di quei dati è" int ".

Questa è stata solo una pessima decisione dei progettisti di C o c'è qualche buona ragione per cui viene analizzata in questo modo? Sono certo che la domanda abbia avuto una risposta prima, ma non riesco a trovarla usando la ricerca.

Answer 1

C'è una pagina web su The Development of the C Language che dice "La sintassi di queste dichiarazioni riflette l'osservazione che i, * pi e ** ppi generano tutti un tipo int quando vengono utilizzati in un'espressione". Cerca quella frase nella pagina per trovare la sezione pertinente che parla di questa domanda.

Answer 2

Ci può essere un ulteriore ragione storica, ma ho sempre inteso in questo modo:

Una dichiarazione, un tipo.

Se a, b, c, d e deve essere lo stesso tipo qui:

int a, b, c, d; 

Poi tutto sulla linea deve un intero come pure.

int a, *b, **c, ***d; 

Le 4 interi:

1. un
2. * b
3. ** c
4. *** d

Può essere correlato alla precedenza degli operatori, pure, o potrebbe essere stato a un certo punto nel passato.

Answer 3

Il * modifica il nome della variabile, non lo specificatore del tipo. Questo è principalmente dovuto al modo in cui viene analizzato il *. Prendete queste dichiarazioni:

char* x; 
char *x; 

Queste dichiarazioni sono equivalenti. L'operatore * deve essere compreso tra l'identificatore del tipo e il nome della variabile (viene trattato come un operatore infisso), ma può andare su entrambi i lati dello spazio. Detto questo, la dichiarazione

int* a, b; 

non avrebbe b un puntatore, perché non c'è * adiacente ad essa. Il * funziona solo sugli oggetti su entrambi i lati di esso.

Inoltre, pensateci in questo modo: quando scrivete la dichiarazione int x;, state indicando che x è un numero intero. Se è un puntatore a un numero intero, allora *y è un numero intero. Quando scrivi int *y;, stai indicando che *y è un numero intero (che è quello che vuoi). Nella dichiarazione char a, *b, ***c;, si sta indicando che la variabile a, il valore senza autorizzazione di b e il valore triple-deferite di c sono tutti di tipo char. Dichiarare le variabili in questo modo rende l'uso dell'operatore stella (quasi) coerente con il dereferenziamento.

Sono d'accordo che sarebbe quasi più sensato che fosse il contrario. Per evitare questa trappola, mi sono fatto sempre una regola per dichiarare i puntatori su una linea da soli.

Answer 4

Le dichiarazioni C sono state scritte in questo modo in modo da utilizzare "dichiarazioni specchi". Questo è il motivo per dichiarare gli array come questo:

int a[10]; 

si dovesse avere invece la regola si propone, dove è sempre

type identifier, identifier, identifier, ... ; 

... quindi array dovrebbe logicamente devono essere dichiarate come questo :

int[10] a; 

che va bene, ma non rispecchia come si usa a. Si noti che questo vale anche per le funzioni, anche - dichiariamo funzioni in questo modo:

void foo(int a, char *b); 

piuttosto che

void(int a, char* b) foo; 

In generale, gli "specchi dichiarazione usano" regola significa che hai solo per ricordare un set di regole di associatività, che si applicano a entrambi gli operatori come *, [] e () quando si utilizza il valore e i token corrispondenti in dichiaratori come *, [] e ().

---

Dopo qualche ulteriore riflessione, penso che sia anche la pena sottolineare che l'ortografia "puntatore a int " come "int*" è solo una conseguenza della "specchi dichiarazione usano" in ogni caso. Se si dovesse utilizzare un altro stile di dichiarazione, sarebbe probabilmente più opportuno digitare "Puntatore su int" come "&int" o qualcosa di completamente diverso come "@int".

Answer 5

Perché se la dichiarazione

int* a, b; 

dovesse dichiarare b come un puntatore troppo, allora non avreste alcun modo per dichiarare

int* a; 
int b; 

su una sola riga.

D'altra parte, si può fare

int*a, *b; 

per ottenere quello che vuoi.

Pensateci in questo modo: il modo in cui è ora è ancora il modo più conciso e tuttavia unico per farlo. Questo è ciò che C è principalmente circa :)

Answer 6

suppongo che è legato alla sintassi completa dichiarazione per tipo modificatori:

int x[20], y; 
int (*fp)(), z; 

In questi esempi, ci si sente molto più evidente che i modificatori sono solo ad uno degli le dichiarazioni. Una ipotesi è che una volta che K & R ha deciso di progettare i modificatori in questo modo, è sembrato "corretto" che i modificatori riguardassero solo una dichiarazione.

Una nota a parte, mi sento di raccomandare solo te stesso limitando ad una variabile per dichiarazione:

int *x; 
int y; 

Answer 7

posso solo immaginare il motivo per cui si dovrebbe ripetere il * per ogni nome di variabile menzionato su una linea per fare tutti loro puntatori. Forse è dovuto a una decisione sulla coerenza linguistica? Lasciatemi illustrare con un esempio:

---

Si ipotizzi di avere una funzione foo dichiarato come segue:

int foo() { ... } 

Supponiamo anche che si desidera dichiarare due puntatori a funzione a questa funzione:

int (*fooptr1, fooptr2)(); 
// this doesn't work; and even if it did, what would the syntax possibly 
// look like to initializing them to function foo? 
// int (*fooptr1 = foo, fooptr2 = foo)() ? 

int (*fooptr1)() = foo, (*fooptr2)() = foo; 
// this works. 

In questo caso, è sufficiente deve ripetere l'intera dichiarazione del tipo B altre variabili, e non puoi sbagliare perché non c'è altro modo per farlo (data la sintassi della dichiarazione C così com'è).

---

Ora, forse si pensava, se ci sono casi in cui la dichiarazione del tipo deve essere ripetuta per tutte le variabili, forse questo dovrebbe essere solo il caso generale.

(non dimenticate che io sono solo indovinando qui.)

Answer 8

consideri la dichiarazione:

int *a[10]; 
int (*b)[10]; 

Il primo è un array di dieci puntatori a numeri interi, il secondo è un puntatore a una matrice di dieci interi.

Ora, se * fosse collegato alla dichiarazione del tipo, non sarebbe sintatticamente valido mettere tra parentesi una parentesi. Quindi dovresti trovare un altro modo per differenziare tra le due forme.