Newsgroup: it.comp.lang.c
Titolo: Come manipolare i singoli bit?

Vorrei fare un programma che, data un'espressione booleana,
tipo F=A AND B OR C.... ecc, riesca a creare una  tabella della
verità dicendomi quando F=1 e quando F=0 per tutte le combinazioni
di bit.
Scrivendo qualcosa simile a
struct StrutturaByte {
                     unsigned Bit8: 1;
                     unsigned Bit7: 1;
                     unsigned Bit6: 1;
                     unsigned Bit5: 1;
                     unsigned Bit4: 1;
                     unsigned Bit3: 1;
                     unsigned Bit2: 1;
                     unsigned Bit1: 1;
                     };
Potrei utilizzare i singoli bit, ma devo anche provare tutte le
256 combinazioni.
Per farlo pensavo di far passare, in una variabile di tipo
char, tutti i numeri da 0 a 255, ma vorrei assegnare a questa
variabile lo stesso indirizzo di memoria della StrutturaByte
in modo che, assegnando ad es. alla var. char il valore 5
i componenti della struttura assumano i valori
Bit1 = 1
Bit2 = 0
Bit3 = 1
Bit4 = 0
Bit5 = 0
Bit6 = 0
Bit7 = 0
Bit8 = 0
Ma come si fa? E' possibile? Se no, qualcuno saprebbe darmi un
consiglio migliore?
Ho le idee un po' confuse.
Grazie cmq.
--
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
e-mail: 
cerch...@ciaoweb.it
 
33813...@tim.it
Bye byte, Cerchietto
La vita, senza una meta, è vagabondaggio
(Seneca)
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_

 Ho le idee un po' confuse.
come l'hai messa tu, cosi':
void imposta(struct StrutturaByte& sb, const unsigned char& c){
  sb.Bit1 = (c & 1);
  sb.Bit2 = ((c>>1) & 1);
  sb.Bit3 = ((c>>2) & 1);
  sb.Bit4 = ((c>>3) & 1);
  sb.Bit5 = ((c>>4) & 1);
  sb.Bit6 = ((c>>5) & 1);
  sb.Bit7 = ((c>>6) & 1);
  sb.Bit8 = ((c>>7) & 1);
}
si usa un unsigned, altrimenti i valori del char sono anche negativi
Penso comunque sarebbe meglio usare un array, o funzioni su un carattere
oppure passi al C++ e usi vector<bool>

 void imposta(struct StrutturaByte& sb, const unsigned char& c){
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Questo e' C++, qui dentro si parla di C.
-- 
Posted from  [80.105.34.80] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Questo e' C++, qui dentro si parla di C.
E una soluzione in C non ci sarebbe?


 E una soluzione in C non ci sarebbe?
Studia su un qualunque manuale di C la sezione relativa agli
operatori bitwise (&, |, <<, >>, ...).


 operatori bitwise (&, |, <<, >>, ...).
Ci sono riuscito.... ma senza gli operatori bitwise,
ho utilizzato union
Ecco l'abbozzo di prova che ho scritto:
========================================
#include <stdio.h>
struct StrutturaByte {
                     unsigned Bit1: 1;
                     unsigned Bit2: 1;
                     unsigned Bit3: 1;
                     unsigned Bit4: 1;
                     unsigned Bit5: 1;
                     unsigned Bit6: 1;
                     unsigned Bit7: 1;
                     unsigned Bit8: 1;
                     };
union UnionSB_Char {
                   unsigned int VarInt;
                   unsigned char VarChar;
                   struct StrutturaByte VarSB;
                   };
main()
{
union UnionSB_Char VarUnionSB_Char;
VarUnionSB_Char.VarInt = 141;        /* Un valore a caso */
printf("\n");
printf("Spazio occupato da VarUnionSB_Char: %d byte\n",sizeof(VarUnionSB_Char));
printf("Var2 = %d\n",VarUnionSB_Char.VarChar);
printf("Var3.Bit1 = %d\n",VarUnionSB_Char.VarSB.Bit1);
printf("Var3.Bit2 = %d\n",VarUnionSB_Char.VarSB.Bit2);
printf("Var3.Bit3 = %d\n",VarUnionSB_Char.VarSB.Bit3);
printf("Var3.Bit4 = %d\n",VarUnionSB_Char.VarSB.Bit4);
printf("Var3.Bit5 = %d\n",VarUnionSB_Char.VarSB.Bit5);
printf("Var3.Bit6 = %d\n",VarUnionSB_Char.VarSB.Bit6);
printf("Var3.Bit7 = %d\n",VarUnionSB_Char.VarSB.Bit7);
printf("Var3.Bit8 = %d\n",VarUnionSB_Char.VarSB.Bit8);
}
========================================
Funziona, ma č la prima volta che utilizzo union, almeno
l'ho utilizzato nel modo corretto?
--
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
e-mail: 
cerch...@ciaoweb.it
 
33813...@tim.it
Bye byte, Cerchietto
La vita, senza una meta, č vagabondaggio
(Seneca)
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_

l'ho utilizzato nel modo corretto?
boh, parrebbe :)  La sintassi del campo di bit mi pare sia proprio
quella, ma io continuo a preferire il bit vector (ADT bit vector per
l'esattezza, come descritta sopra).
Comunque se ti serve uno spunto posso postare una versione
(potenzialmente instabile perche' assume che il char sia sempre di 8
bit, fornita dal mio prof di ASD).
Mox

 bit, fornita dal mio prof di ASD).
Spero almeno che sia "potenzialmente" comprensibile per me :-)
Grazie tante.
--
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
e-mail: 
cerch...@ciaoweb.it
 
33813...@tim.it
Bye byte, Cerchietto
La vita, senza una meta, è vagabondaggio
(Seneca)
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_

Spero almeno che sia "potenzialmente" comprensibile per me :-)
Ci ho dato una passata di correzione, non l'ho usata molto quindi
potrebbero esserci dei bug ma spero proprio di no. Comunque questo
serve da spunto, devi vedere com'e' stato implementato per poi
riutilizzare i concetti :)
<CODE>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define BYTESIZE CHAR_BIT
#DEFINE OK    1
#DEFINE ERROR 0
#IFNDEF FALSE
#  DEFINE FALSE 0
#ENDIF
#IFNDEF TRUE
#  DEFINE TRUE (!FALSE)
#ENDIF
typedef unsigned char byte;
typedef struct {
  int size;
  byte *bytestream;
} set;
#define SIZE(S) ((S)->size)
#define BYTES(S) ((S)->bytestream)
static byte bit[BYTESIZE] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
0x80};
int set_Init(set *p_S, int size)
{
	int numbytes, i;
	numbytes = (size + BYTESIZE - 1) / BYTESIZE;
	BYTES(p_S) = malloc(numbytes);
	if (BYTES(p_S) == NULL)
		return ERROR;
	SIZE(p_S) = numbytes * BYTESIZE;
	for (i=0; i<numbytes; i++)
		BYTES(p_S)[i] = 0;
	return OK;
}
//Inserisce element nel set
int set_Insert(set *p_S, int element)
{
	if (element < 0 || element >= SIZE(p_S))
		return ERROR;
	BYTES(p_S)[element/BYTESIZE] |= bit[element%BYTESIZE];
	return OK;
}
//Controlla che elemento faccia parte del set
bool set_Member(set *p_S, int element)
{
	if (element < 0 || element >= SIZE(p_S))
		return FALSE;
	return (BYTES(p_S)[element/BYTESIZE] & bit[element%BYTESIZE])
? TRUE : FALSE;
}
</CODE>
Mox

 <CODE>
[cut]
Veramente non c'ho capito molto, anzi, quasi niente:
con il C sono ancora agli inizi, lo sto studiando dal
Trichy C. Man mano che lo studio spero di capire
il codice. Grazie tante.
Simone.
