Newsgroup: it.comp.lang.c
Titolo: unioni

Ciao a tutti,
vorrei chiedere il vostro parere a proposito dell'utilizzo di alcuni
tipi unione.
Partiamo per esempio dalla seguente definizione:
union
  {
   double var1;
   float var2;
  } variabileunione = {104};
A norma di standard č consentito qualunque accesso al primo membro, essendo
quest'ultimo l'oggetto attivo, mentre qualsiasi accesso a "var2" decade in
undefined behaviour.
Se modifico la mia unione e la faccio diventare una:
union
   {
   const double var1;
   float var2;
   } variabileunione = {104};
E' ovvio che a partire da questo punto posso leggere, ma non modificare, il
membro "var2";
ma se successivamente faccio il seguente assegnamento:
   variabileunione.var2 = 100;
non potrň piů far riferimento a "var1" senza decadere in un undefined. Non
vedo il modo di rendere
"var2" nuovamente l'oggetto attivo. Pertanto un unione con campi const che
utilizzo portabile puň avere?
Medesima domanda mi pongo con un'unione come:
union
   {
   double var1;
   volatile float var2;
   } variabileunione = {104};
L'oggetto membro inizializzato č sempre "var1", ma il campo "var2" - dato
che potrebbe variare in
modo asincrono -, non comporta che ogni lettura al membro "var1" decada in
un undefined? Dopo tutto
un eventuale valore fuori controllo da parte del mio programma potrebbe
portare il membro var1 ad una
rappresentazione non valida.
Grazie. Ciao.

 undefined behaviour.
??? Esiste un concetto chiamato "oggetto attivo" riguardante le union?
Mai sentito. A me pare che hai le idee parecchio confuse al riguardo.
Tira un profondo respiro, fai qualche prova e poi rispiegaci i tuoi
problemi.
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

Mai sentito.
Sono d'accordo con Enrico.
Scusa SOPOCO, ma hai provato a compilare gli spezzoni del tuo codice?
A  me  non  risulta  che  tu  possa  utilizzare  la definizione const
all'interno della union. Puoi dichiarare const l'intera union.
I campi delle union sono  dei  sinonimi  della  stessa  locazione  di
memoria.
Scondo me hai fatto degli esempi non reali...
Ciao
GIGI
-- 
   THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
visit my home page:
http://web.tiscali.it/KilometroZero

 Scondo me hai fatto degli esempi non reali...
No, sono tutti reali. Non ho lo standard sotto mano, quindi le cose che
riporto controllatele pure.
Partiamo dal fatto che lo standard specifica che:
"la modifica di  un oggetto const-qualified parziale o totale è considerato
undefined behavior"
"l'accesso - lettura e/o scrittura ad un oggetto volatile-qualified medinate
un l-value non qualificato come volatile è considerato undefined behavior"
"Se una rappresentatione di trap è ottenuta tramite un l-value che non ha un
character type che modifica totalmente o in parte un oggetto si ha un
undefined".
"Accedere ad un membro di un unione quando l'ultima memorizzazione è stata
effettuata su un altro membro decade in un undefined a meno che non si stia
effettuando un type punning valido"
Inoltre, sempre lo standard specifica che un tipo di dato derivato - sia
esso struttura sia esso "unione" - non è influenzato da un eventuale tipo
qualificato dichiarato tra i suoi membri. Quindi penso che questo non
esclude un oggetto const dichiarato fra i suoi membri.
Quindi, riprendiamo gli esempi
union
   {
   const double var1;
   float var2;
   } variabileunione = {104};
Ho inizializzato il primo campo, quello qualificato const. Ma se faccio un
assegnamento successivo a var2 credo di ottenere un undefined, perché dopo
tutto come effetto laterale il valore del membro dichiarato const è
cambiato.
E per quanto riguarda:
union
   {
   volatile double var1;
   float var2;
   } variabileunione = {104};
come la posso utilizzare?
Ammettendo che io assegni a var2 qualcosa. Se l'altro membro può cambiare in
modo asincrono rispetto al mio programma, il valore che io ho assegnato a
var2 -oltre ad essere cambiato- potrebbe decadere in una rappresentazione di
trappola causando un undefined behavior.
Be, spero di essere stato più chiaro adesso.
Ciao.

 Be, spero di essere stato più chiaro adesso.
Chiarissimo. E scusa se avevo pensato che stessi dicendo stranezze (come
hai fatto a mantenerti così calmo :-) ).


modo asincrono rispetto al mio programma, il valore che io ho assegnato a
[CUT]
In generale le variabili di tipo const vengono poste dal linker in un
segmento  di  memoria  diverso  da quello in cui vengono poste quelle
variabili, insomma quelle normali.
Nel caso di un programma per PC entrambi i segmenti sono in  RAM,  ma
dovrebbero comunque essere separati, quindi anche una varaibile const
e' modificabile, accedendovi in  modo  indiretto  con  un  puntatore.
In  pratica  la scritta const e' una direttiva per il compilatore, il
quale, durante la compilazione, verifica se  non  si  facciano  degli
accessi  diretti  a  delle  variabili  di  tipo const. Ma poi dirante
l'esecuzione del programma si puo' fare cio'  che  si  vuole  con  un
semplice  puntatore.
Questa  cosa non e' vera nei programmi per i microprocessori, dove le
variabili sono in RAM e  le  constanti  in  ROM  e  quindi  non  sono
fisicamente modificabili.
Per  questi  motivi  ritengo che non sia corretto mescolare variabili
const e normali all'interno di una union.
Mi pare di capire che tu lavori su PC, invece io di solito lavoro con
altri  microprocessori e microcontrollori e a me certe operazioni non
sono consentite.
Anche volatile e' una direttiva per il compilatore.
Talvolta il compilatore per semplificarsi la vita utilizza delle  sue
variabili  temporanee  in cui carica il valore delle variabili reali,
processa i loro valori e poi riversa  il  contenuto  delle  variabili
temporanee in quelle reali.
Se  una  variabile  e'  di tipo volatile non passa mai attraverso una
variabile temporanea, in modo che in qualunque momento si utilizzi il
suo  valore istantaneo e reale, che puo' essere modificato da qualche
altra procedura che gira in  background,  ad  esempio  una  procedura
stimolata da un interrupt.
Praticamente no ci si deve stupire che una variabile volatile cambi di
valore tra due accessi consecutivi in lettura. Ma puoi scrivere  cio'
che vuoi e come vuoi.
Secondo  me  le  cose  son  molto  piu'  semplici  di quanto tu tema.
Io ti consiglio di mantenere distinte  i  tipi  di  variabili,  anche
perche'  con  un  programma  complesso rischi di perdere il controllo
degli accessi alla memoria.
Ciao
GIGI
P.S.
Scusate gli errori di battitura


 GIGI
Grazie.

 restrittivo per quanto riguarda gli accessi alla rete :-)
Spero che non sia nulla di grave. Comunque in bocca al lupo.
Bye
GIGI
--------------------------------
Inviato via 
http://usenet.libero.it