Per le informazioni riferite a questo argomento e per compilare i programmi è stata usata la vers. 5.01 di mikroBasic Pro.
Altre versioni del compilatore potrebbero avere comportamenti diversi o non funzionare.

Puntatori

' Dichiara un puntatore a byte
dim puntbyte as ^byte

' Dichiara un puntatore a word
dim puntword as ^word

Prima di usare un puntatore, è necessario dichiararne il tipo di dati. Per fare questo, aggiungere il carattere "^" prima del tipo.

dim puntbyte as ^byte
dim puntword as ^word

In questo modo abbiamo dichiarato 2 puntatori che puntano a 2 tipi diversi di variabile.
Non possiamo usare, ad esempio, il puntatore puntbyte, per puntare ad una variabile diversa dal tipo byte, oppure il puntatore puntword, per puntare ad una variabile diversa dal tipo word.
Questo perchè, nella dichiarazione, noi indichiamo, col tipo, la dimensione della variabile da puntare e, se assegnassimo un indirizzo di variabile di altro tipo, avremmo degli errori nell'esecuzione nel programma.

Puntatori

' Dichiara variabile byte
dim pippo as byte
' Ricava indirizzo della variabile
puntbyte = @pippo

Appena dichiarato, il puntatore non punta ancora a nulla (ovvero punta ad un indirizzo casuale) e dobbiamo assegnargli l'indirizzo di una variabile a cui puntare, per poterlo usare.
Per fare ciò, si mette il carattere "@" davanti al nome della variabile a cui deve puntare.

puntbyte = @pippo

In questo modo, il puntatore riceverà l'indirizzo della variabile.

Puntatori

' scrive valore in pippo
pippo = 45
puntbyte^ = 45

Ora, se vogliamo scrivere un valore (o leggerlo), nella variabile pippo, lo possiamo fare in due modi:

pippo = 45 (modo diretto)
puntbyte^ = 45 (modo indiretto)

Mettendo il carattere "^" dopo il nome del puntatore, indichiamo di voler accedere al contenuto della variabile puntata.

In ambedue i casi, verrà scritto il valore 45 nella variabile pippo.

program prova_puntatori
'16F877A - 8MHz
' dichiarazione delle variabili
dim pippo as byte
dim pluto as word
dim topolino as byte
dim ptr_pippo as ^byte
dim ptr_pluto as ^word

main:
' istruzioni di esecuzione
    while true
        ptr_pippo = @pippo
        ptr_pluto = @pluto
        pippo = 15
        pluto = pippo
        ptr_pippo^ = 8
        ptr_pluto^ = pippo
        topolino = ptr_pippo^ + 1       
        topolino = ptr_pluto        'consentito
        ptr_pippo = ptr_pluto       'errore
    wend
end.

Proviamo a vedere, con il programmino a fianco e con l'uso del debugger software, cosa succede, in pratica, smanettando con i puntatori.

Dopo averlo compilato, notiamo, prima di tutto, che la compilazione è avvenuta

(1) con successo, senza errori

(2) ma con 2 avvertimenti (warning).

Gli avvertimenti (al contrario degli errori) non bloccano la compilazione e segnalano solo situazioni anomale e possibili malfunzionamenti del programma.
Dobbiamo essere noi, che programmiamo, a tenerne conto ed, eventualmente, correggere le istruzioni segnalate se sono effettivamente sbagliate.

Il compilatore non può conoscere i nostri "trucchi" di programmazione e ci segnala delle situazioni che, per esso, sono sospette. In questo caso si lamenta, dicendo:

"Conversione di puntatori sospetta"

alle linee 18 e 19 del listato.

(3) Alla linea 18, l'istruzione

topolino = ptr_pluto

assegna ad una variabile di tipo byte, il valore contenuto in un puntatore (cioè un indirizzo).
L'operazione è perfettamente possibile perchè il valore contenuto nel puntatore è di tipo byte (valore da 0 a 255).
Questo non creerà dei malfunzionamenti, se sappiamo cosa stiamo facendo.

(4) Alla linea 19, invece, l'istruzione

ptr_pippo = ptr_pluto

assegna il valore di un puntatore a word ad un puntatore a byte.
Anche qui, essendo, i 2 valori, 2 indirizzi ed entrambi di tipo byte, la cosa è possibile ma creerà un malfunzionamento, durante l'esecuzione del programma, perchè, il puntatore, punterà ad una variabile di dimensione sbagliata (word invece che byte).

A volte, lavorare con i puntatori, è più agevole che lavorare con le variabili direttamente ma, sempre se si sa bene quello che si sta facendo.

(6) L'istruzione

ptr_pippo = @pippo

assegna l'indirizzo della variabile pippo, di tipo byte, al puntatore a byte ptr_pippo.
In altre parole, il valore contenuto nel puntatore ptr_pippo, sarà l'indirizzo della variabile pippo.

(7) L'istruzione

ptr_pluto = @pluto

assegna l'indirizzo della variabile pluto, di tipo word, al puntatore a word ptr_pluto.
In altre parole, il valore contenuto nel puntatore ptr_pluto, sarà l'indirizzo della variabile pluto.

(8) L'istruzione

pippo = 15

assegna semplicemente il valore 15 (0x0F in esadecimale) alla variabile pippo.

Questo si dice "assegnamento diretto".

(9) L'istruzione

pluto = pippo

assegna il valore della variabile pippo, di tipo byte, alla variabile pluto, di tipo word.

(10) L'istruzione

ptr_pippo^ = 8

assegna il valore 8 alla variabile puntata dal puntatore ptr_pippo, la quale è pippo.

(11) In altre parole, assegna il valore 8 alla variabile, il cui indirizzo (0x27) è contenuto nel puntatore ptr_pippo.

Questo si dice "assegnamento indiretto" perchè fatto tramite puntatori.

(12) L'istruzione

ptr_pluto^ = pippo

assegna il valore della variabile pippo, alla variabile puntata dal puntatore ptr_pluto, la quale è pluto.

In altre parole, assegna il valore della variabile pippo, alla variabile, il cui indirizzo (0x23) è contenuto nel puntatore ptr_pluto.

(13) L'istruzione

topolino = ptr_pippo^ + 1

assegna alla variabile topolino il valore contenuto nella variabile puntata da ptr_pippo ed aggiunge 1.

(14) L'istruzione

topolino = ptr_pluto

assegna alla variabile topolino il contenuto del puntatore ptr_pluto.

L'operazione è perfettamente legale, basta sapere cosa farci.

(15) L'istruzione

ptr_pippo = ptr_pluto

assegna al puntatore ptr_pippo, il contenuto del puntatore ptr_pluto.

I 2 valori sono entrambi degli indirizzi ma, di variabili di tipo diverso e questo può causare comportamenti strani nel funzionamento, a meno che, questo, sia usato volutamente come trucco di programmazione.

I puntatori servono anche a questo ma, a volte, possono diventare campi minati, se usati male.

Variabili, memoria, strutture dati

Puntatori (2)