Newsgroup: it.comp.lang.c
Titolo: AND logico

Eseguo una semplice mask del tipo:
char x = 'a';
int bit = x & 1;
1 cos'è? Un singolo bit 1 (dubito, visti i risultati ottenuti), oppure una
stringa di bit del tipo 00000001 ?? 
E in quest'ultimo caso quanti 0 ci sono prima dell'1? 
esiste un modo per fare l'AND col "bit 1" ?
Grazie e scusate la banalità della domanda.

 stringa di bit del tipo 00000001 ?? 
1 è un literale intero che vale (indovina un po?) 1.
La domanda sorge spontanea: che risultato ti aspettavi?

 Grazie e scusate la banalità della domanda.
Di niente
-- 
Quando noi ignoranti eravamo di più, tutto era più bello (A. Celentano).
  ___   _   ___ _  _______   _______ ___
|   \ /_\ | _ \ |/ / _ ) \ / /_   _| __|
| |) / _ \|   / ' <| _ \\ V /  | | | _|
|___/_/ \_\_|_\_|\_\___/ |_|   |_| |___|

 Ovviamente, sizeof(char)-1
cioè 0 visto che sizeof(char) è garantito essere 1 da tutti gli standard
qualcosa non torna eh? =)
-- 
sbi

 qualcosa non torna eh? =)
Si, non torna l'orario in cui ho postato :)
Intendevo dire la dimensione _in bit_ della variabile char :)


 
Grazie, sei stato molto esauriente, ma ora avrei un'altra domanda.
Sospettavo che le cose andassero come le hai descritte, solo che ho avuto
dei problemi con un banale pezzetto di codice che dovrebbe semplicemente
ritornarmi i singoli bit di una stringa. E' il seguente:
char *a = "a";
int s = strlen(a)*8;
for (i=0;i<=s;i++) 
        printf("%d ",(*a >>(s-i)))&1));
non so se si capisce immediatamente, ma lo shift right serve ad "allineare"
col bit 1 (con cui si fa l'AND), il bit della stringa al posto i.
Iterando il ragionamento per strlen(a) volte, si ottengono i bit del
carattere desiderato.
Credo che la codifica sia ASCII, perchè ottengo il seguente risultato:
01100001 ----> 97 = "a" sulla ascii table;
Ora arriva il problema; se la stringa ha più caratteri, ad esempio:
char *a = "abc";
non ottengo il risultato desiderato, ma solo la sequenza 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1
cui solo gli ultimi 8 bit sembrano essere corretti, ma corrispondenti al
carattere "a", invece che al carattere "c" aspettato.
Pensavo che forse il puntatore a carattere referenzia solo il primo byte
della variabile puntata, per questo mi restituisce questa sequenza.
Allora come fare ad accedere agli altri bit??
Ho provato con l'aritmetica dei puntatori (*(a+i), a[i]...) ma non ottengo
ancora risultati validi.
Cosa posso fare?
Grazie.

Vincent Vega wrote:

Ir realtà il risultato ottenuto è corretto, perchè la suddetta operazione
logica mi restituisce "1". Infatti l'AND logico tra le stringhe 01100001
(il carattere 'a' dichiarato) e 00000001 (il bit 1), è proprio 1!
Poi basta shiftare a destra il 'a' e ripetere l'AND, per strlen(x)*8 (=
ovvero 8, nel caso di un singolo carattere) volte per ottenere tutti i bit.
E infatti, fin qui tutto ok.
Il problema, come dicevo anche nella risposta a Darkbyte, sorge nel momento
in cui invece di un singolo char ho un char* formato da più caratteri: in
questo caso riesco a reperire solo i bit del primo carattere della stringa,
non gli altri.
Un aiutino per il niubbo?????

 Un aiutino per il niubbo?????
-- 


 ancora risultati validi.
Una possibilita' e' che su ogni a[i]  fai il lavoro di estrarre gli 8 
bit corrispondenti. (Per intenderci qualcosa del tipo:
char a[] = "abc";
int i,j,s = sizeof(a)-1, sc=7;
for (j=0;j<s;j++)
    { printf("\n");
    for (i=0;i<=sc;i++)
        printf("%d ",  (a[j]>>(sc-i)) & 1);
    }
Giorgio

 sinistra" del bit meno significativo dell' indirezione di a[0].
oops ! leggi:  .... del bit meno significativo di a[0]
Giorgio

    };
Ok, grazie... ho trovato una soluzione più "sintetica" (ma forse anche meno
leggibile) per estrarre l'i-mo bit da una generica stringa str:
(str[i/8]>>(7-(str%8)))&1)
Testato e funzionante...
grazie a tutti per il supporto

 (cioè char, 8 bit).
Non e` di tipo int? Dovrei rileggere le regole di promozioni dei tipi ma
AFAIK /x/ viene promosso ad int proprio per il fatto che la costate 1 e`
di tipo int.
Luca
-- 
Home: 
http://kronoz.cjb.net
I went to God just to see
And I was looking at me
Saw heaven and hell were lies
When I'm God everyone dies

 operando dell'and deve essere a 8 bit.
Direi che non è vero, anzi.

 non gli altri.
Dipende quello che devi fare. Di sicuro è un problema che non sussiste, 
puoi scorrerti il puntatore e accedere agli altri char come al primo.

> Direi che non è vero, anzi.
Ovviamente parlavo del lato matematico della cosa, cioè il principio.
Non posso eseguire:
0100111100
  AND
   00111001
a meno che non faccio un padding della seconda stringa...


 a meno che non faccio un padding della seconda stringa...
Lascia stare le stringhe, stiamo parlando di numeri binari.
Posso fare (e faccio regolarmente):
int i, b;
b = 1234;
i = b & 0xFF;
Il "padding" si chiama promozione che avviene secondo delle regole 
conosciute (a questo scopo, attenzione ai signed e agli unsigned).

 conosciute (a questo scopo, attenzione ai signed e agli unsigned).
Appunto :)


 Appunto :)
Appunto? Non diciamo la stessa cosa.

 Testato e funzionante...
(Dlin-dlon! Trasmettiamo ora: "Il momento della pignoleria".)
Funziona solo se il tipo char del compilatore ha 8 bit... È vero che
*praticamente* il tipo char ha sempre 8 bit ma, *teoricamente* potrebbe
averne di più (non di meno).
Siccome, nella mia carriera, ho visto parecchi "teoricamente" trasformarsi
in "praticamente" da un anno all'altro, suggerirei di trasformare le
costanti hard-code3d "8" e "7" in, rispettivamente, "CHAR_BIT" e "(CHAR_BIT
- 1)".
CHAR_BIT è una macro contenuta nel file <limits.h> che dà, ovviamente, il
numero di bit contenuti in un byte. Si tratta di un valore costante, quindi
il codice, una volta compilato, è perfettamente identico a prima.
--
Cingar
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Appunto? Non diciamo la stessa cosa.
Secondo me ci stiamo incartando...


 ALTRIMENTI non si potrebbe eseguire l'AND.
E' lapalissiano. Come è lapalissiano che sia una regola del linguaggio 
(valida per tutti gli operatori, non solo logici bit a bit).

> Quindi, riassumendo: dici che si può o dici che non si può?
In C o in altri linguaggi si che si può.
E' il concetto da lui espresso che io dicevo che non andava (non aveva 
senso)... ripeto, per pignoleria mia ho lasciato fraintendere quello che 
intendevo. Ma di certo non volevo dire che non posso fare l'and logico 
fra un char e un int in C.


P.S.: Complimenti per il nick :)
E salutami Jules ;)


 quindi il codice, una volta compilato, è perfettamente identico a prima.
Evviva la pignoleria... se è sempre così utile!!
Grazie 0x3E8 !!!
        Fabbro