Newsgroup: it.comp.lang.c
Titolo: L'operatore &

Vuongiorno e scusate,
ho bisogno di avere un'ampia e completa  documentazione sull'uso
dell'operatore & sui bit.
Potete aiutarmi?
Grazie
Pietro



domanda generica.. che vuoi sapere ?
inutile che ti dica che fa l'and bid a bit no ?
vuoi un esempio ?..
 int a = 41770;
 int b = 58634;
 int c = a & b;
'c' è uguale a 41226, perché 
a: 0000 0000 0000 0000 1010 0011 0010 1010  and
b: 0000 0000 0000 0000 1110 0101 0000 1010  =
c: 0000 0000 0000 0000 1010 0001 0000 1010
cia`
matico

 ha scritto nel messaggio
news:Z3I6b.299484$Ny5.9...@twister2.libero.it...

l'operatore AND = & e' la normale operazione binaria di AND logico ...
quindi:
1 and 1 = 1
1 and 0 = 0
0 and 1 = 0
0 and 0 = 0
ora questo procedimento applicato ad un singolo bit lo puoi appplicare anche
ad una serie di bit, es:
101010101010 and
000011110000 =
000010100000
come ben vedi si fa l'and logico bit a bit con i bit della stessa posizione
delle due serie binarie.
spero che quello che ti ho detto ti basti per capire come si calcola l'and
perche' non c'e' molto altro da dire, ed anche leggendo un trattato di 200
pagine ne esce cmq questo succo ... se non hai capito ancora come funziona
mi sa che non vai tanto bene per programmare :-p
ciao

ma allora cosa sifbifica questo pezzo di codice sapendo che ColorVal è un
numero tipo 7 oppure 23 oppure 133 ecc.... e che rappresenta un colore?
{
 char ColorString[10];
 int ColorVal,i , IsNoColor;
 /* If no numeric parameter given
     then return a null string
 */
 if ( ! ISNUM(1) )
 {
  _retc( "" );
  return;
 };
 /* Get Parameter */
 ColorVal = _parni(1);
 /* Check foreground color */
 i = 0;
 IsNoColor = TRUE;
 /* Check blue bit */
 if (ColorVal & 1 )
 {
  ColorString[i] = 'B';
  i++;
  IsNoColor = FALSE;
 };
 /* Check Green  bit */
 if (ColorVal & 2 )
 {
  ColorString[i] = 'G';
  i++;
  IsNoColor = FALSE;
 }
 /* Check Red  bit */
 if (ColorVal & 4 )
 {
  ColorString[i] = 'R';
  i++;
  IsNoColor = FALSE;
 };
 if (IsNoColor)
 {
  ColorString[i] = 'N';
  i++;
 }
 /* Check High intensity  bit */
 if (ColorVal & 8 )
 {
  ColorString[i] = '+';
  i++;
 };
 /* This is the separator between foreground and background
  string
 */
 ColorString[i] = '/' ; i++ ;
 // Now the background
 IsNoColor = TRUE;
 if ( ColorVal & 16 )
 {
  ColorString[i] = 'B';
  i++;
  IsNoColor = FALSE;
 };
 if (ColorVal & 32 )
 {
  ColorString[i] = 'G';
  i++;
  IsNoColor = FALSE;
 };
 if (ColorVal & 64 )
 {
  ColorString[i] = 'R';
  i++;
  IsNoColor = FALSE;
 };
 if ( IsNoColor )
 {
  ColorString[i] = 'N';
  i++;
 };
 if (ColorVal & 128 )
 {
  ColorString[i] = '*';
  i++;
 };
 ColorString[i] = 0;
 _retc( ColorString );
 return;
}
Molte grazie e scusate per gli errori ho la tastiera a pezzi e molto speeso
alcune lettere non le scrive


 numero tipo 7 oppure 23 oppure 133 ecc.... e che rappresenta un colore?
si ... guardando cosi  come hai postato quello stralcio di codice non fa
nient'altro che avendo il valore numerico di un componente scrivere una
stringa con i componenti trovati ...
cmq non so dirti di piu' ... ma dove hai trovato quel coso ??? sei sicuro
che e' C e non C++ ??? in C++ gli operatori potrebbero avere il significato
completamente stravolto ...
ciao

  if (ColorVal & 4 )
[SNIP]
Semplice, rappresenta un colore come un intero signed (dovrebbe
rappresentarlo come unsigned per essere certi del risultato) e poi
controlla i singoli bit.
Per controllare il bit in posizione 3 (da destra, considerando quello piu' a
destra con valore 0) si mette il valore in AND bit-a-bit con una maschera
di questo tipo 1<<3, cioe' 8 in decimale. Puoi anche definire questa
maschera in modo equivalente come 2^3 (sempre 8).
Questa e' tutta la spiegazione tecnica. Spero ti sia chiaro il perche' si
usa l'AND bit-a-bit per controllare se un bit e' impostato e come si fa' ad
"alzare" o "abbassare" un determinato bit.
Personalmente preferivo usare degli array di unsigned char piuttosto che un
unsigned int, per avere un maggior controllo e una maggior portabilita':
sulla totalita' dei sistemi che conosco io un char e' di 8 bit e posso
scoprirlo leggendo il valore di una define, mentre la dimensione degli int
varia e devo ricalcolarmela su ogni sistema.
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

 significato completamente stravolto ...
A me pare proprio C. 


 ha scritto nel messaggio
news:hFN6b.300447$lK4.9...@twister1.libero.it...


 oppure 128 di un numero tipo il numero 65 decimale ovvero 1000001?
Per controllare la posizione di un certo bit si mette la variabile
(assumiamo un unsigned char) in AND bit-a-bit con una maschera che ha solo
quel determinato bit alzato.
65 == 01000001
Metterlo in AND bit-a-bit con 4 significa fare:
DEC     BIN              DEC     BIN
65    01000001           65    01000001
 4    00000100           64    01000000
      --------                 --------
 0    00000000           64    01000000
Il risultato non ha molto senso se lo guardi in decimale, ma ne ha di piu'
in binario.
Poi il tutto si basa su come viene valutato secondo l'algebra booleana il
risultato.
0 viene valutato False, tutto il resto True.
Se il risultato era 0 significa che il bit non era alzato, se c'e' un
qualunque altro risultato, significa che il bit era alzato invece.
