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

Rieccomi con qualche altra stupida domanda (e direi proprio che poi sono
finite...):
1) se dichiaro una variabile volatile, e gli assegno ad esempio la porta del
joystick(è solo un esempio, non so assolutamente come si fa, quindi se
sbaglio in partenza...), il valore della variabile cambia anche mentre il
programma sta elaborando altre istruzioni, vero? E' questo il metodo per
gestire mouse, joy, etc?
2) su vari manuali c'è scritto che le var globali possono portare effetti
collaterali. Quali?
3) per usare set di istruzioni speciali (es. 3dnow, simd, mmx...) si deve
ricorrere solo alle istruzioni asm, o magari esistono librerie apposite?
Esistono per caso compilatori in grado di ottimizzare direttamente per
questi set?
Grazie.
--
Marco Iannaccone
ICQ: 18748121
IRC: Tolkien
e-mail: 
captai...@ussvoyager.com

collaterali. Quali?
Un esempio molto banale puo' essere :
#include <stdio.h>
int i ;
int funz ()
{
    int i = 0 ;
    while ( i <= 10 ) i++ ;
}
main()
{
  funz() ;
}
Immagina di rinominare la i dichiarata localmente in funz() con j, ma
di non rinominare la variabile del ciclo.

 collaterali. Quali?
Rompono la modularità del codice e l'information hiding provocando molti
problemi nel momento in cui vai a rimetterci le mani.
EMG

Allora mica potresti fare un esempio d'uso di variabile volatile?
Grazie


 Grazie
Prego :-)
Gia' sai che volatile informa i lcompilatore che una variabile puo' 
essere modificata con modalita' non direttamente sotto il suo controllo.
Supponi un registro associato a un unita' periferica che accetta 
caratteri da una tastiera.
Lo socpo della seguente funzione è di leggere un carattere daslla tasiera 
e di passarlo a c0 poi il sucessivo e passarlo a c1:
void_get_2_byte(void)
{
 extern char KEYBOARD;
 char c0,c1;
 c0 = KEYBOARD;
 C1 = KEYBOARD;
}
Il; compilatore ignaro che il valore di KEYBOARD possa essere modificato 
all'esterno motlo probabilmente assegna il valore a un registro che 
assegna a c0 e successivamente a c1 quindi interpreta in questo modo(o 
anche meglio:):
void_get_2_byte(void)
{
extern char KEYBOARD;
char c0,c1;
register char temp;
temp = KEYBOARD;
c0 = temp;
c1 = temp;
}
Per garantire che KEYBOARD venga letta due volte bisogna dichiararla 
volatile: extern volatile char KEYBOARD;
UN altra situazione simile è data  dalle espressioni costanti all'interno 
dei cicli in cui le comuni tecniche di ottimizzazione possono alterare il 
significato di un programma,supponiamo ora di dover leggere 10 caratteri 
consecutivi dalla tastiera e passarli alla funzione copy():
Usiamo ancora KEYBOARD:
void leggi_10_char(void)
{
  esxtern char KEYBOARD;
  extern void copy(int);
  int x;
  char c;
  for(x = 0; x < 10; x++)
  {
     c=KEYBOARD;
     copy(c);
  }
} 
 
Dal punto di vista del compilatore questa funzione è inefficiente perche' 
assegna a c lo stesso valore per 10 volte,quindi potrebbe ottimizzarla 
cosi:
void_leggi_10_char(void)
{
  extern char KEYBOARD;
  extern void copy(int);
  int x;
  char c;
  c=KEYBOARD; /*L'espressione costante viene rimnossa dal ciclo*/
 
  for(x = 0; x < 10; x++)
      copy(c);
}
In questo modo lo stesso carattere  viene inviato alla funzione 
copy()ogni volta che viene chiamata.Dichiarando KEBOARD come voltaile 
assicuri che l'espressione costante non venga rimossa dal ciclo,
pertanto a copy()verranno passati tutti e dieci i caratteri digitati.
UN'altro caso è dato dalle espressioni che contengono conversioni di tipo 
esplicto(cast):
....
char car;
car = (*(volatile char *) 0X20);
...