Può esserci un puntatore a un puntatore a un puntatore?

Question

Se ci sono dei puntatori in C (char * nomi []) e puntatori ai puntatori (char ** cur_name = nomi); Può esserci un puntatore a un puntatore a un puntatore?

Oppure è un puntatore a un puntatore a un puntatore solo un elenco collegato? Forse è una domanda stupida, ma mi piacerebbe sapere la risposta.

Answer 1

Sì, è possibile avere un numero arbitrario di livelli di puntatori.

int x = 5; 
int *a = &x; 
int **b = &a; 
int ***c = &b; 

printf("%d %d %d %d\n", x, *a, **b, ***c); 

Un puntatore a un puntatore a un puntatore è non una lista collegata. Una lista concatenata è un tipo di struttura che contiene un puntatore al proprio tipo:

struct list 
{ 
    int data; 
    struct list *next; 
}; 

In modo che è possibile concatenare insieme in un elenco:

struct list three = { 3, NULL }; 
struct list two = { 2, &three }; 
struct list one = { 1, &two }; 
struct list head = { 0, &one }; 

E scorrere su di loro:

for (struct list *node = &head; node->next; node = node->next) 
{ 
    printf("%d\n", node->data); 
} 

Answer 2

Diciamolo in termini più semplici.

Dichiarare una variabile - non ha importanza di quale tipo - e rappresenta una posizione nella memoria.

int foo=1; 

Si può quindi dichiarare un'altra variabile che punta a che variabile.

int *bar; 
bar = &foo; 

Estendere nuovamente - dichiarare un puntatore a che variabile ... e così via.

int *baz; 
baz = &bar; 

Il punto è che non c'è alcun limite per i livelli di indirezione a cui potrebbe essere usata o dichiarata un dato puntatore. E, sintatticamente, si può fare

int ****nthLevelPointer; 

Ora, tenendo traccia di che nel codice in modo che qualcun altro potrebbe avere per mantenere è un altro problema del tutto :)

Answer 3

Un semplice esempio:

struct List 
{ 
    struct List* next ; 
} 

struct List a ; 
struct List* p = &a ; 
p->next = p ; 
p = p->next ; 
p = p->next->next ; 
p = p->next->next->next ; 
p = p->next->next->next->next ; 
p = p->next->next->next->next->next ; 
p = p->next->next->, ... ,next->next->next ; 

indica che non esiste un limite teorico alla profondità di puntatore di riferimento.

Answer 4

Risposta breve: I puntatori puntano agli indirizzi in memoria, che possono contenere più puntatori. Il limite è il numero di indirizzi disponibili.

Risposta più breve: Sì, può esserci un puntatore-puntatore-puntatore.

Answer 5

La tua risposta è sì. I puntatori sono solo riferimenti alla memoria. Quindi se possiamo fare riferimento alla memoria possiamo anche fare riferimento al puntatore. puoi ottenere le dimensioni, in abbondanza del tuo processo. puoi definirle anche per variabile locale.assumere questo schema:

puntatore un -----> puntatore b -----> puntatore c ------> (variabile locale o definire variabile in mucchio)

Answer 6

Un puntatore a un puntatore a un puntatore è possibile.

se declarate una variabile in questo modo:

int ***ptr; 

poi:

-> ptr will be a pointer to a pointer to a pointer to an int variable 
-> *ptr will be a pointer to a pointer to an int variable 
-> **ptr will be a pointer to an int variable 
-> ***ptr will be a int variable 

quindi:

highest pointer level: ptr 
    ...     *ptr 
    ...    **ptr 
int variable   ***ptr