Newsgroup: it.comp.lang.c
Titolo: Alias di variabili in C?

Mi ponevo questo quesito. Supponiamo che io abbia una struttura del
tipo:
typedef struct
{
   char accumulator;
   char register_x;
   char register_y;
   char stack_pointer;
   char processor_status;
   short program_counter;
} state;
e che abbia definito una 'variabile':
state status;
Ora, al posto di dover scrivere ogni volta che mi serve
status.program_counter, non posso definire un bell'alias di questa
variabile e chiamarla PC, in modo che il compilatore capisca che ogni
volta che uso PC in realtà intendo status.program_counter? (E' solo
per un fatto di comodità e maggior leggibilità)
Ho dato un'occhiata sul mio unico libro (misto C/C++), e ho trovato un
accenno al cosiddetto "Tipo Reference", cioè esattamente quello che
cercavo; lui afferma che se scrivo
int double;
int &copia = double;
da questo momento in poi copia e double sono in pratica la stessa
variabile. Neanche a dirlo nel DJGPP questa sintassi non funziona
(praticamente nessuna delle sintassi che il libro mi propone funziona
mai al primo colpo.... ;)
Chiedo lumi...
Ciao ciao, Piero.

Io fossi in te userei solo il preprocessore:
# define NOMEBREVE simbolopallosodascrivere
Non mi avventurerei nell' uso di sintassi esotiche, magari
derivate da interpretazioni opinabili degli standard.
Non conosco C++, ma l' esempio che fai non e' sicuramente C.
int double; /* credo errato. double e' una keyword */
            /* e non dovrebbe essere usata come identificatore */
La notazione &copia e' una espressione compile time che restituisce
il puntatore alla variabile copia GIA' DEFINITA!
Puoi usare i puntatori, ma non sono alias, ma variabili che
contengono, come valori, indirizzi di altre variabili a cui il
programma ha accesso (questa ultima cosa la sottolineo).
quindi:
struct miastruttura {
 int campo_1;
 double campo_2;
} scheda;
int * p_campo_1;
double * p_campo_2;
p_campo_1 = &scheda.campo_1;
p_campo_2 = &scheda.campo_2;
ora hai due puntatori che puntano direttamente ai campi di scheda,
ma tutte le istruzioni successive che faranno riferimento hai valori
devono essere ( * p_campo_1) /* puntato da p_campo_1 */
e (* p_campo_2) /* puntato da campo 2 */
te lo SCONSIGLIO!
L' uso del preprocessore, che e' uno strumento standard ANSI che deve
accompagnare tutti i compilatori aderenti allo standard, serve anche
a questo.
ciao.


 mai al primo colpo.... ;)
Forse perché cerchi di compilare in C dei costrutti C++. Il DJGPP
riconosce come sorgenti C quelli con estensione .C e come sorgenti C++
quelli con estensione .CC. Prova a rinominare i tuoi.
EMG

 int &copia = double;
Non mi sembra che il C standard supporti quella sintassi, al massimo
	int* var1 = &var2
utilizzando i puntatori, quella che dici tu penso funzioni in C++.
Ah, oops, mi sono accorto adesso di una cosa, tu hai usato il nome
"double" che e' un nome di tipo del C !!!!!
Resta cmq il fatto che non penso sia corretto in C, ditemi se sbaglio.
-- 
Zack
Stefano Zacchiroli
zacc...@cs.unibo.it
za...@comune.budrio.bo.it
ICQ# 33538863
"Never understimate the dark side"

 "double" che e' un nome di tipo del C !!!!!
No? Ero convinto di si, ma non ho voglia di controllare e mi fido.
Provvederò a trasformare tutti i double in long float :-)
--
Alessandro Monti

int &copia = double;
Ehm, ovviamente double non va bene come nome; è un errore del taglia e
incolla... non vi accanite, lo so. In C &copia è solo l'indirizzo
della variabile, ok.
...quindi niente alias in C (ve l'ho detto che il mio libro è misto
C++).
Ancora mille grazie per l'aiuto.

Ops, avevo capito male.

you wrote :
#> int double;
#> int &copia = double;
#
#Questo funziona solo in C++ e non in C.
E credo che non sia neanche &copia ma 
int d ;
int& copia = d ;
o sbaglio ?
(Almeno per i parametri di funzione in C++ e' cosi')
--------------------------------------------------------
* Andrea Laforgia        (
andrea_...@bigfoot.com
) *
--------------------------------------------------------

 (Almeno per i parametri di funzione in C++ e' cosi')
Scrivere
int d ;
int& copia = d ;
o
int d ;
int &copia = d ;
è la stessa identica cosa anche nei parametri di funzione.
EMG

 
ma imho e' preferibile la seconda, in quanto un eventuale:
	int& a, b;
e' equivalente a
	int &a, b;
ossia b e' un int normale.
(ovviamente questo non vale per i parametri di funzioni,
perche' di ognuno va specificato il tipo).
Per evitare confusioni...
-- 
Emanuele Cesena                 
http://www.penguinpowered.com/~ecesena
ece...@penguinpowered.com
                 Attenti all'antispam NOSPAM
			Cosa dire quando si e' incazzati
		 (Ovvero: risposte di classe a domande cretine)
1.  Che un caprone immenso si mangi la tua grondaia durante la stagione
    dei monsoni.
2.  Che un grillo prenda dimora nello stetoscopio del tuo dottore un
    attimo prima del tuo check-up annuale.
3.  Che un fanatico venditore di prefabbricati appiccichi con lo scotch
    5000 picchi alla tua casa.
		-- Da 
http://www.sis.it/~megabyte/likka/
 dei
		   The New Likka Boyz, [1/6]

 ma imho e' preferibile la seconda,
Anche per me.
EMG