E 'possibile avere puntatori ricorsivamente in se stessi?

Non è così che funzionano i puntatori.

Un puntatore è, in sostanza, una registrazione di un indirizzo di memoria. Se sottoposto a dereferenziazione , puoi leggere (o scrivere) il valore che vive in quell'indirizzo.

I puntatori possono indicare tutto ciò che vive nella memoria. In particolare, possono indicare altri indicatori. Possono persino puntare su se stessi (anche se è abbastanza inutile).

Tuttavia , l'azione di dereferenziazione di un puntatore deve essere presa esplicitamente. Un puntatore che punta a un altro puntatore restituisce il valore di quell'altro puntatore quando lo si denomina , non automaticamente. E se quell'altro puntatore punta a una terza cosa, raggiungere la terza cosa richiede due azioni esplicite.

Un puntatore non si trasforma magicamente nella cosa indicata nelle tue mani. Pertanto non è possibile creare strutture di riferimento che elaborino per sempre senza avere un ciclo esplicito nel mix. Tale loop può essere eseguito all'infinito, come qualsiasi loop con una condizione di terminazione insufficiente, ma è necessario il ciclo, non solo i puntatori.

Una spiegazione molto schematica

Idea di base: Un puntatore è una variabile che memorizza un indirizzo di memoria (in genere 4 byte)

es.

char* t_pointer; // This Pointer is a 4 bytes variable that will contain (but currently does not contain) the memory address of a char 

Impostazione di un valore del puntatore: Un modo tipico consiste nell'utilizzare l'operatore "di &" o l'operatore di riferimento applicato a una variabile

es.

char t_char = ‘a’; // A 1 byte variable containing character 'a'
char* t_pointer = &t_char; // The pointer now contains the memory address of the 't_char' variable 

Ottenere il valore dell'elemento appuntito: Viene utilizzato l'operatore di dereferenza "*", quindi la sintassi (*t_pointer) restituisce il contenuto dell'indirizzo di memoria memorizzato in t_pointer

Due osservazioni:

• non esiste alcuna limitazione sull'indirizzo di memoria che il puntatore può memorizzare in modo che possa puntare a un'area di memoria valida, anche a se stessa, nonché a un'area di memoria non valida L'utilizzo dell'operatore di dereferenziazione implica il tentativo di accedere a quella regione di memoria ed è qui che possono verificarsi problemi

• C e C ++ sono lingue tipizzate, quindi è necessario capire qual è il tipo di valore a cui accede l'operatore di dereferenziazione Nell'esempio sopra, il t_pointer è definito come (char*) quindi significa che quando si dereferenzia si ottiene char ... questo significa che durante il dereferenziamento si sta fondamentalmente leggendo un byte solo come sizeof(char) è 1 In caso di int* t_pointer , il dereferenziamento causerebbe la lettura di sizeof(int) che è tipicamente di 4 byte

Infine, considera che non sei strongmente vincolato dal tipo di puntatore, dato che puoi eseguire il casting

es.

void* t_pointer; // Pointer to an undefined type 
int t_int = 11; // Int Variable 
t_pointer = &t_int; // Memory address of the first byte of the int

variabile     int t_res = (int) (* t_pointer); // Dereferenziare il puntatore specificando di leggere un int e memorizzare quel valore in una nuova variabile