differenza tra il doppio puntatore e array di puntatori

Question

In un normale programma di c/C++ che scrivere funzione principale sia come

int main(int c, char **argv) 

o

int main(int c, char *argv[]) 

Qui argv rappresenta un array di puntatori ma anche rappresentare doppio puntatore (puntatore al puntatore) usando **.

es:

char p,*q,**r; 
q=&p; 
r=&q; 

Ecco r è un doppio puntatore e non array di puntatori.

Qualcuno può spiegare la differenza?

Answer 1

Grazie Quando viene utilizzato come parametro di funzione

char a[] // compiler interpret it as pointer to char 

è equivalente a

char *a 

e allo stesso modo, in firma main s', char *argv[] equivale a char **argv. Si noti che in entrambi i casi char *argv[] e char **argv, argv è di tipo char ** (non un array di puntatori!).

Lo stesso non vale per la dichiarazione

char **r; 
char *a[10]; 

In questo caso, è r di tipo puntatore a puntatore a char mentre a è di tipo array di puntatori a char.
L'assegnazione

r = a; // equivalent to r = &a[0] => r = &*(a + 0) => r = a 

è valida perché in questa espressione nuovamente matrice tipo a verrà convertito puntatore al suo primo elemento e quindi del tipo char **.

Ricorda sempre che gli array e i puntatori sono di due tipi diversi. I puntatori e le matrici equivalenza significa aritmetica dei puntatori e indicizzazione degli array equivalenti.

Lettura consigliata:

• But I heard that char a[] was identical to char *a.
• Why are array and pointer declarations interchangeable as function formal parameters?

Answer 2

argv è un argomento in modo che l'array sia decaduto al puntatore e non vi è altra via che la dimensione (int c) da differenziare.

Quando un puntatore doppio e una matrice di puntatori non sono gli argomenti, la loro sintassi può sembrare simile a volte ma il loro tipo è diverso e quindi il compilatore genera diversi tipi di codice per entrambi.

Se la variabile di interesse non è l'argomento della funzione, sizeof darà una dimensione diversa per il puntatore al puntatore e alla matrice di puntatori.

domanda un po 'correlato: extern declaration, T* v/s T[]

Answer 3

sguardo! puntatori doppie in realtà negozio come questo
Diciamo

int p,*q,**r; 
p=50; 

diamo l'indirizzo della p è 400 (&p è 400) se scriviamo q=p e stampare q avremo 400 come la risposta in quanto q si riferisce alla l'indirizzo di p e *p renderà 50 come output dal operator * si riferisce a "valore all'indirizzo". Ora, cerchiamo di dire q ha l'indirizzo 500 (&q uscite 500) quindi quando facciamo così: r=q il r contiene il valore 500 e prefisso r con * cioè *r l'uscita deve essere 400 perché r rende il valore di q che memorizza l'indirizzo di p come variabile puntatore.

quindi,
se in un programma C corriamo il seguente codice

int main() 
{ 
    int p,*q,**r; //assume the address of p to be 400 
       //assume the address of q to be 500 
    p=50; 
    q=p; 
    r=q; 

printf("Value of p-->%d",p); 
printf("\nValue of q-->%d",q); 
printf("\nValue at address of q \"in the address displayed above\"-->%d",*p); 
printf("\nValue of r \"which will be the address of q\"-->%d",r); 
printf("\nValue of r \"which will be the adddress of p-->%d",*r); 
printf("\nValue of r \"which will be the value of p\"-->%d",**r); 
/* 
Please change the format specifiers and replace the specifier from %d to %u in case the address value is not being displayed 
*/ 
return 0; 
} 

USCITA
-------
valore di P -> 50
Valore di Q- -> 400
Valore all'indirizzo q "nell'indirizzo visualizzato sopra" -> 50
Valore di r "che sarà l'indirizzo di q" -> 500
Valore di r "che sarà l'adddress di p "-> 400
valore di R "che sarà il valore di p" -> 50

Attraverso l'esempio di cui sopra, ho solo cercato di spiegare l'uso di un doppio puntatore. Forse potresti sapere questo ancora ho reso chiaro il punto

Ora utilizzando l'esempio precedente con array.
Look
Gli array sono già puntatori poiché possono essere avvocati con riferimento come * (a + 1) o a [1].
Quindi, i doppi puntatori possono significare array di puntatori o una stringa di stringa come da domanda. L'uso delle notazioni a doppio puntatore dipende dalla situazione.
Nella domanda che hai postato sopra il _TCHAR ** argv o semplicemente char ** argv è l'array di caratteri per l'input della console che è sempre accettato come flusso di caratteri.
In java, usiamo qualcosa di simile come public static void main (String argv [])
Questo mostra chiaramente che il metodo principale accetta input che sono la matrice di array di caratteri (o Stringhe per essere un po 'generici).
Spero tu abbia capito la differenza. Se non gentilmente commentare. Te lo spiegherò.
si