Accedere ad un arry di che con puntatore int

ter2
Autore della discussione
Giovane Utente

Di più

9 Anni 6 Mesi fa #1 da ter2

Accedere ad un arry di che con puntatore int è stato creato da ter2

Salve a tutti,

è un pò che mi frulla quest'idea in testa ma non riesco ad implementarla.

Ambiente MikroC for PIC32, ma credo sia utilizzabile su qualsiasi microcontrollore.

Vorrei scrivere in un vettore un byte alla volta, e poi leggerne due per volta.
Mi spiego meglio. Se io definisco

Code:

unsigned char Indirizzi[4];
unsigned int* Indirizzi_int = Indirizzi;

Posso usare Indirizzi[] per scrivere un byte alla volta,
e Indirizzi_Int[] per leggerne due.

Ovviamente se l'arrai Indirizzi[4] è allocato consecutivamente in memoria ( e credo che sia così).

Il compilatore non da problemi, ma il pic si blocca arrivato all'istruzione:

Code:

lunghezza = Indirizzi_Int[1]-Indirizzi_Int[0];

Dove lunghezza è un char.

Mi sfugge qualcosa?

Si prega Accesso o Crea un account a partecipare alla conversazione.

alfa75
Platino Utente

Di più

9 Anni 6 Mesi fa #2 da alfa75

Risposta da alfa75 al topic Accedere ad un arry di che con puntatore int

Ciao ter

non ho ben capito cosa vuoi fare...
ma una cosa posso dirtela di sicuro, il tipo di variabile del puntatore (char,int,ecc....) deve essere dello stesso tipo della variabile "puntata".
Quindi nel tuo caso non puoi far puntare una variabile char con una di tipo int.

qui sotto ti metto un link dove c'e una spiegazione abbastanza fatta bene sui puntatori
www.science.unitn.it/~fiorella/guidac/guidac056.html

spero di esserti stato utile

Saluti
Andrea

Si prega Accesso o Crea un account a partecipare alla conversazione.

ter2
Autore della discussione
Giovane Utente

Di più

9 Anni 6 Mesi fa #3 da ter2

Risposta da ter2 al topic Accedere ad un arry di che con puntatore int

Ciao alfa75,

Ho letto il tuo link, e la cosa è fattibile.

In pratica un puntatore non è altro che un indirizzo di memoria.
La definizione di un tipo influenza solo la sua aritmetica.
pointer++;
incrementa di una posizione se pointer è definito come char* ( dimensione 1 byte)
oppure incrementa di due posizioni se pointer è definito come int* (dimensione 2 bytes)

Detto questo ho scritto questo codice:

Code:

unsigned char Indirizzi[4];
unsigned int* Indirizzi_int = Indirizzi;
Indirizzi[0] = 0x01;
Indirizzi[1] = 0xF0;
Indirizzi[2] = 0x02;
Indirizzi[3] = 0x0A;
Print_Byte(Indirizzi[0]);
Print_Byte(Indirizzi[1]);
Print_Byte(Indirizzi[2]);
Print_Byte(Indirizzi[3]);
Print_Int(Indirizzi_Int[0]);
Print_Int(Indirizzi_Int[1]);

LA risposta al terminale è:

il byte è 01
il byte è F0
il byte è 02
il byte è 0A
l'int è F001
l'int è 0A02

Quindi l'idea di base funziona. Il problema è l'interpretazione dei due byte letti in memoria: a quanto pare il compilatore legge prima il byte meno significativo ( il primo byte letto è 0x01) e poi il più significatico (secondo byte letto è 0xF0). Ecco perchè la ricostruzione risulta invertita.

Sapete dermi se è una cosa propria del mio compilatore o se è una cosa comune?
Esiste un modo per modificare questo tipo di interpretazione dei dati?

Grazie per il vostro tempo.

Si prega Accesso o Crea un account a partecipare alla conversazione.

Mauro Laurenti
Moderatore

Di più

9 Anni 6 Mesi fa #4 da Mauro Laurenti

Risposta da Mauro Laurenti al topic Accedere ad un arry di che con puntatore int

ti consiglio l'uso del casting o semplicemente un movimento manuale dei byte del tipo:

var_int = ((int) byte_2 ) <<

| (int) byte_1;

faresti in maniera manuale quello che vorresti che il compilatore facesse per te.

Se fai uso del simulatore potresti capire meglio cosa succede dietro le quinte.

Saluti,

Mauro

Si prega Accesso o Crea un account a partecipare alla conversazione.