Newsgroup: it.comp.lang.c
Titolo: LEGGETTE!Quasi importate!! :-D

Salve, scusate l' oggetto ma, mi serviva per attirare la vostra
attenzione... In effetti a questo serve l' oggetto o no? :-D
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~
La vera domanda è questa................................
Vi è una funzione o una normalissima specifica di conversione che permette
di stampare lo stato(0 o 1) di ogni singolo bit in memoria di uno specifico
dato? Quindi che mi stampa il relativo codice binario.
Aspetto vostre risposte... ci conto. Ciao... ;-)
-----------------
Posted by PRG
-----------------

 dato? Quindi che mi stampa il relativo codice binario.
in C non mi ricordo ... in C++ nella libreria <iomanip> ci sono definiti i
manipolatori per trasformare gli input/output cosi da poter stampare in
binario ottale hex ecc ... ecc ...
ciao

 attenzione... In effetti a questo serve l' oggetto o no? :-D
no, non serve proprio a questo
l'oggetto serve a dare una rapida descrizione del tuo problema, in modo che
se è lo stesso di altri lo raggiungano subito, quindi cerca di evitare
questi titoli, sono abbastanza fastidiosi.
per quanto riguarda la tua domanda se ho capito il problema mi pare una
normale conversione in binario, facendo attenzione alla codifica con cui
sono salvati i dati.
FRa

 vorrei sapere se esiste una funziona o una Specifica di conversione
banalmente:
num & 1 per sapere se il bit meno significativo e' a 1
num >>1 per shiftare a destra di un bit
ripeti finche' num==0
-- 
-=[]=---iAN CooG/TWT+HokutoForce---=[]=-
"Non ti fidare di chi ti da consigli e poi ti insulta, stronzo!"

 "Complemento a 2".
non tutti i dati sono rappresentati in complemento a 2 per il float penso si
usi l'IEEE p754,
per i dati rappresentati in complemento a 2 invece basta fare una
funzioncina se la cerchi in rete la trovi di sicuro..

 ottale hex ecc ... ecc ...
Quale sarebbe il manipolatore di iomanip che permette di stampare in
binario?
Poi questo e' un NG di C......
Tommy

  codice binario.
Umh, non dici di quale dato.... Sei molto vago...
Quindi l'unica soluzione che posso proporti e' una funzione ad hoc che e'
flessibile quanto la tua domanda e' vaga!
Ad esempio potresti fare qualche cosa del genere:
void StampaBin(void *pDato, unsigned int nSizeOf)
{
    unsigned char *mem=(unsigned char*)pDato;
    unsigned char mask;
    while(nSizeOf>0){
        --nSizeOf;
        mask=0x80;
        while(mask){
            putchar(
                (mem[nSizeOf] & mask)?('1'):('0')
            );
            mask >>= 1;
        }
    }
    putchar('\n');
}
In C potresti subito ricevere pDato come "unsigned char*". Tuttavia un
compilatore C++ (molti compilano C con compilatori C++) non sarebbe molto
felice.
Ecco che allora ricevo pDato come void* e poi con un cast lo faccio puntare
da mem che e' invece un uchar*.
Come dicevo mem (e tutto questo passaggio) non servirebbe in C.
Bene, questa funzione stampa il "dato" in formato binario. Spesso e' piu'
utile una funzione che ritorna una stringa contenente la rappresentazione
ASCII del valore binario (invece di stampare direttamente); ovviamente
adattare il programma e' semplice....
Vediamo come chiamare la funzione:
unsigned char c = 2;
...
StampaBin(&c,sizeof(unsigned char));
Bene il risultato sara':
00000010
(ah, non mi dite che sizeof(char) e' sempre 1, lo so, ma e' per spiegare
come va usata la funzione.....)
Il bello di questa funzione e' che e' molto flessibile:
int i1 = 59000;
int i2 = -59000;
...
StampaBin(&i1,sizeof(int));
StampaBin(&i2,sizeof(int));
Il risultato sara':
00000000000000001110011001111000
11111111111111110001100110001000
(sulla maggior parte delle macchine)
A dimostrazione della flessibilita' possiamo mostrare un double:
double d = 258.45;
....
StampaBin(&d,sizeof(double));
E sulla mia macchina il risultato e':
0100000001110000001001110011001100110011001100110011001100110011
Finisco mostrando che e' persino applicabile ad array e strutture:
struct custom{
    unsigned int a[2];
    unsigned char b;
    unsigned int c[3];
};
...
struct custom s;
...
memset(&s,0xFF,sizeof(struct custom));
s.a[0]=0; s.a[1]=0;
s.b=0;
s.c[0]=0;s.c[1]=0;s.c[2]=0;
Tutto questo serve per settare tutti i bits della struttura ad 1.
Poi settiamo ogni campo a 0.
Il risultato e' quello di vedere se e quanti bits di padding sono stati
inseriti......
StampaBin(&s,sizeof(struct custom));
Sulla mia macchina ho:
0000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000011111111111111111111111100000000000000000000000000000000
0000000000000000000000000000000000000000
Come e' possibile vedere ci sono 24 bits (3 bytes) di padding.
Questo era anche possibile notarlo con:
sizeof(struct custom) - (sizeof(int)*5 + sizeof(char))
che sulla mia macchina restituisce 3.
Ovviamente se invece di inserire tutti 0 nei campi "validi" inseriamo dati
"interessanti" la nostra funzione e' in grado di stampare i bits
correttamente, ovvio.
Spero possa essere di aiuto per raggiungere il tuo scopo.
Tommy