Perché un char * viene trattato come un char ** in C?

Question

Ho la seguente applicazione di test:

#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 

int main(void){ 
    char buf[512]; 
    buf[0]= 0x1; 
    buf[1]= 0x2; 
    char *temp1 = &buf; 
    char *temp2 = buf; 
    char *temp3 = &buf[0]; 
    printf("temp1:%p, temp2:%p, temp3:%p\n",temp1,temp2,temp3); 
    printf("0 = %d, %d, %d\n",temp1[0],temp2[0],temp3[0]); 
    printf("1 = %d, %d, %d\n",temp1[1],temp2[1],temp3[1]); 
    return; 
} 

Si compila con un avvertimento:

Ma quando l'eseguo, tutti e tre i puntatori si comportano allo stesso.

./testptr 
temp1:0x7fff3a85f220, temp2:0x7fff3a85f220, temp3:0x7fff3a85f220 
0 = 1, 1, 1 
1 = 2, 2, 2 

so che buf == &buf[0], ma perché &buf == &buf[0]? Non dovrebbe &buf essere un char**?

Answer 1

Tutti i puntatori si comportano allo stesso perché dichiarato tutti loro di essere char*. C è tipizzato staticamente in modo che il tipo sia associato alla variabile e non al valore.

Ora che la parte relativa al comportamento è stata spiegata, abbiamo solo bisogno di scoprire perché hanno effettivamente lo stesso valore (come per% p printf). Bene, questo è solo un artefatto di puntatori implementati come indirizzo di memoria da GCC (gli offset e il dimensionamento che fanno un * differiscono da un ** sono tutti gestiti dal sistema di tipi/compilatore dietro le quinte).Si noti che, come una delle cose più sospette che emette avvisi, è probabile che si tratti di un comportamento indefinito o almeno una cattiva pratica :)

Answer 2

Gli array non sono puntatori, sebbene possano essere utilizzati più o meno allo stesso modo. È capitato di aver trovato un aspetto in cui la semantica degli array e dei puntatori differisce.

Answer 3

È possibile ricavare dall'algebra degli operatori * e &.

• sappiamo che buf è l'indirizzo dell'elemento 0-esimo dell'array buf

• sappiamo che &buf[0] è anche l'indirizzo dell'elemento 0-esimo

• per definizione buf[0] è equivalente a *(buf+0)

• e &(*(a)) equivale a a.

Quindi, &buf[0] diventa &(*(buf+0)) che è buf.

Aggiornamento

Qui, cerchiamo di stenderlo come una prova.

1. &buf[0] Dato.
2. &(buf[0]) da regole di precedenza C con (s '
3. &((*(buf+0))) perché buf[0] == *(buf+0)).
4. &(*(buf+0)) eliminando parentesi estranee
5. buf QED

Answer 4

Se si pensa a quale codice viene effettivamente generato dal compilatore quando elabora un array, diventa più chiaro. Il nome buf fa riferimento all'indirizzo del primo elemento (zeroth) dell'array (spazio contiguo per contenere i caratteri). Se guardi l'oggetto alla voce della tabella dei simboli per "buf", troverai l'indirizzo di quel primo elemento. Quando fai riferimento, ad es., Buf [0], il compilatore genera l'indirizzo di buf, più zero volte la dimensione di un carattere. Questo è uguale all'indirizzo di buf stesso.