Dereferenziare un puntatore a un array?

Question

Riferendosi alla linea con il commento:

• Perché l'aggiunta di parentesi nel lavoro di esempio per stampare tutto il contenuto della matrice?

L'esempio stampa "uno", quindi stampa immondizia.

#include <iostream> 

int main() { 
    const char* a[3] = { "one", "two", "three" }; 
    const char*(*p)[3] = &a; 
    for(int i = 0; i < 3; i++) { 
     std::cout << *p[i] << std::endl; // this line 
    } 
    return 0; 
} 

Funziona dopo aver cambiato a questo:

std::cout << (*p)[i] << std::endl; 

Answer 1

p è un puntatore a un array di 3 elementi simili:

┌─────┬─────┬─────┐ 
│  │  │  │ 
└─────┴─────┴─────┘ 
^
    └─ p 

noti che indica l'intero array, non un singolo elemento di essa.

L'espressione *p[i] viene considerata come *(p[i]) a causa della precedenza dell'operatore (che equivale a *(*(p + i))). Ciò significa che stai indicizzando il puntatore all'array. Se lo fai p[1], per esempio, si sposta il puntatore lungo alla matrice "next" e tentare di dereferenziarlo:

┌─────┬─────┬─────┐ 
│  │  │  │ 
└─────┴─────┴─────┘ 
        ^
        └─ p + 1 

Come possiamo vedere, non c'è niente, e si otterrà un comportamento indefinito. Tuttavia, quando si esegue (*p)[i] (equivalente a *((*p) + i)), ci si assicura che il dereferenziamento avvenga prima. La dereferenzia ci fornisce la matrice stessa, che può quindi essere convertita implicitamente dalla conversione da matrice a puntatore a un puntatore al primo elemento delle matrici. Quindi, quello che si ottiene è:

┌─────┬─────┬─────┐ 
│  │  │  │ 
└─────┴─────┴─────┘ 
^
    └─ *p 

In questo caso, il puntatore sta indicando la matrice elemento e non l'intero array. Se poi si indice, per esempio, (*p)[1], si otterrà:

┌─────┬─────┬─────┐ 
│  │  │  │ 
└─────┴─────┴─────┘ 
     ^
     └─ (*p) + 1 

Questo vi dà una valida const char* che possono poi essere restituito dal cout.

Answer 2

Operator precedence.

La selezione matrice hanno priorità più alta rispetto dereferenziare, quindi dal punto di vista compilatori è veramente:

*(p[i]) 

Answer 3

Operator precedence. Senza () operatore [] sarà chiamato primo risultato sarà dereferenced. Con () - in primo luogo sarà dereference e quindi chiamare l'operatore [].

Answer 4

 #include <iostream> 
     using namespace std;  

     int main() { 


      int arr[5] = {1,2,3,4,5}; 

      int *p=arr; 


      int intgerSize=sizeof(int); 


      for(int k=0;k<5;k++) 


      { 
       cout<<"arr ["<<k<<"] "<<*(p+(k*sizeof(int)/intgerSize)); 
       cout<<" "<<(p+(k*sizeof(int)/intgerSize)); 
       cout<<" "<<p+k<<"\n"; 

      }`enter code here` 

      return 0; 
     } 
OUTPUT:- 
arr [0] 1 0x7ffd180f5800 0x7ffd180f5800 
arr [1] 2 0x7ffd180f5804 0x7ffd180f5804 
arr [2] 3 0x7ffd180f5808 0x7ffd180f5808 
arr [3] 4 0x7ffd180f580c 0x7ffd180f580c 
arr [4] 5 0x7ffd180f5810 0x7ffd180f5810