Newsgroup: it.comp.lang.c
Titolo: dividere una variabile "unsigned 16" in due "unsigned 8"

Ciao,
scusate per la domanda che potrebbe essere assurda.
io ho 3 variabili dichiarate:
unsigned char pippohi  //8bit
unsigned char pippolo  //8bit
unsigned short pippone //16bit
main:
pippone = 5000;
qui' vorrei splittare pippone nelle due variabili 8 bit.
end main
Sapete se è possibile e come si fa' ?
grazie
Pippo

 Sapete se è possibile e come si fa' ?
Ovviamente ci sarà un modo, penso che con operazioni di rotate e shift 
sui bit si riesca a fare.
-- 
God is real, unless if declared integer.
Powered by Debian GNU/Linux

 qui' vorrei splittare pippone nelle due variabili 8 bit.
pippohi = pippone >> 8;
pippolo - pippone & 0xff;
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   Registered Linux user #337974  < 
http://giovanni.homelinux.net/
 >

 
Ciao Giovanni,
credo che tu abbia voluto scrivere:
pippohi = pippone >> 8;
pippolo = pippone & 0xff;
In realtà mi sono agganciato al tuo thread per fare una domanda al NG:
Per rispettare standard e piattaforme quelle due semplici righe postate 
da Giovanni si dovrebbero scrivere così?
#define BitSize(x) (8 * sizeof x)
main()
{
unsigned char pippohi;
unsigned char pippolo;
unsigned short pippone;
typedef unsigned short us;
typedef unsigned char uc;
pippone = 5000;
pippolo = pippone & (us)(uc)~0;
pippohi = (pippone & ((us)(uc)~0) << BitSize(pippohi)) >> BitSize(pippohi);
printf("\none:%0X hi:%0X lo:%0X", pippone, pippohi, pippolo);
}
... e, che la seguente soluzione risulta essere inaffidabile?
main()
{
union {
	unsigned short one;
	unsigned char split[2];
} u;
u.one = 5000;
printf("\none:%0X hi:%0X lo:%0X", u.one, u.split[1], u.split[0]);
}

 Giovanni
Grazie
ciao
Pippo

 }
se sei sicuro che sizeof(short) == 2*sizeof(char) allora si. Altrimenti (ad 
esempio se short e' 32bit) non funziona.
Non so quanto sia portabile, ma nelle applicazioni embedded (dove di solito 
non il porting e' limitatissimo) e' una soluzione utilizzatissima.
Ciao Jack
-- 
http://motoko.dyndns.org

 Ciao Jack
Grazie per la risposta. E' proprio ciò che mi stavo domandando. Intendo 
dire che *se* secondo gli standard sizeof(char) è sempre 1 e *se* le 
union rimappano ciascun dato immesso partendo dalla parte più bassa 
della memoria contestuale, allora dovrebbe funzionare anche se 
sizeof(short) *non* è 2*sizeof(char).
Negli altri casi si dovrebbe fare una verifica dopo la valorizzazione di 
u.one del tipo:
if(u.one >= (unsigned short)~0)
Sto sbagliando il ragionamento?
Un saluto.
dMaxime.

pippo ha scritto:

A parte quello che ti hanno già detto si potrebbe anche pensare di fare 
così:
pippolo=(*(unsigned char *)&pippone)[0];
pippohi=(*(unsigned char *)&pippone)[1];
(non testato)
E.

 E
Non e' portabile perche dipendente dall endianness della piattaforma ;-)
(se BIG ENDIAN, lavora al contrario di quanto atteso).
La forma suggerita nel 3d
 higbyte = (myVar >> 8);
 lowByte= (myVar& 0xff);
e' piu' portabile e non dipende dall' endianess o dal size di myVar 
(basta che sia >= 16bit).
B.

 unsigned short pippone;
...perche', per lo standard, USHRT_MAX >= 65535. Quindi un 'unsigned short' 
sara' sempre "almeno" 16bit (2^16 - 1), qualunque sia l'architettura o il 
compilatore; ma, ovviamente, non e' detto che sia "esattamente" 16bit...
Piu' sotto ti copio/incollo la parte dello standard (C99) che riporta questi 
valori minimi. Ricorda che quelli effettivi, ed esatti, del compilatore che 
stai usando sono definiti in <limits.h>, e possono solo essere uguali o 
maggiori di quelli riportati qui sotto. Inoltre, la serie di '#define' che 
trovi in <limits.h> puo' esserti molto utile per il tuo esercizio di 
"parametrizzazione".
Buon divertimento. ;-)
PS. mi viene anche da fare una domanda riguardo allo shift: vuoi trovare il 
"byte alto" e il "byte basso" ... ma qual e' l'uno, e qual e' l'altro?
http://it.wikipedia.org/wiki/Ordine_dei_byte
======
ISO/IEC 9899:1999 (E) - p. 23
[...]
5.2.4.2.1 Sizes of integer types <limits.h>
The values given below shall be replaced by constant expressions suitable 
for use in #if preprocessing directives. Moreover, except for CHAR_BIT and 
MB_LEN_MAX, the following shall be replaced by expressions that have the 
same type as would an expression that is an object of the corresponding type 
converted according to the integer promotions. Their implementation-defined 
values shall be equal or greater in magnitude (absolute value) to those 
shown, with the same sign.
-- number of bits for smallest object that is not a bit-field (byte)
CHAR_BIT 8
-- minimum value for an object of type signed char
SCHAR_MIN -127 // -(2^7 - 1)
-- maximum value for an object of type signed char
SCHAR_MAX +127 // 2^7 - 1
-- maximum value for an object of type unsigned char
UCHAR_MAX 255 // 2^8 - 1
-- minimum value for an object of type char
CHAR_MIN see below
-- maximum value for an object of type char
CHAR_MAX see below
-- maximum number of bytes in a multibyte character, for any supported locale
MB_LEN_MAX 1
-- minimum value for an object of type short int
SHRT_MIN -32767 // -(2^15 - 1)
-- maximum value for an object of type short int
SHRT_MAX +32767 // 2^15 - 1
-- maximum value for an object of type unsigned short int
USHRT_MAX 65535 // 2^16 - 1
-- minimum value for an object of type int
INT_MIN -32767 // -(2^15 - 1)
-- maximum value for an object of type int
INT_MAX +32767 // 2^15 - 1
-- maximum value for an object of type unsigned int
UINT_MAX 65535 // 2^16 - 1
-- minimum value for an object of type long int
LONG_MIN -
2147483647
 // -(2^31 - 1)
-- maximum value for an object of type long int
LONG_MAX +2147483647 // 2^31 - 1
-- maximum value for an object of type unsigned long int
ULONG_MAX 4294967295 // 2^32 - 1
-- minimum value for an object of type long long int
LLONG_MIN -9223372036854775807 // -(2^63 - 1)
If the value of an object of type char is treated as a signed integer when 
used in an expression, the value of CHAR_MIN shall be the same as that of 
SCHAR_MIN and the value of CHAR_MAX shall be the same as that of SCHAR_MAX. 
Otherwise, the value of CHAR_MIN shall be 0 and the value of CHAR_MAX shall 
be the same as that of UCHAR_MAX (15). The value UCHAR_MAX shall equal 
2^CHAR_BIT - 1.
Forward references: representations of types (6.2.6), conditional inclusion 
(6.10.1).
15) See 6.2.5.
-- 
Cybertoldo
Per rispondermi via email, sostituisci moc.liamg con 
gmail.com