Newsgroup: it.comp.lang.c++
Titolo: Variabili a dimensione 4 byte o 2 byte

mi sembra di aver letto che se dichiaro un int non so quanto
effettivamente occuperà in byte e la stessa cosa vale per gli short,
per i long, ecc.
se volessi creare una variabile che occupi esattamente quattro byte e
trattarla come intero (e quindi non char[4]), come faccio?
come viene memorizzata? se in esadecimale è 4E20 viene scritto 20 nel
primo byte e 4E nel secondo o viceversa? posso saperlo in qualche modo
(lo so che dipende dall'architettura del computer)?
esistono modi "standard" per capire in che sistema operativo sto
compilando un determinato file?
-- 
]\/[ad]\/[age (
www.madmagelab.cjb.net
)
"Un Maestro insegue semplicemente la sua visione di Eccellenza in
qualunque cosa sta facendo e lascia agli altri decidere se sta 
lavorando o giocando. A lui sembra sempre di fare entrambe." - Anonimo

 compilando un determinato file?
No.
Ciao!
*** Azimuth ***

 datatype.
E' garantito che char==byte?
--
Gerolamo

 trattarla come intero (e quindi non char[4]), come faccio?
Se vuoi essere sicuro puoi farti la tua classe basandoti su
<bitset> così tagli la testa al toro....
--
Gerolamo

 compilando un determinato file?
No, direi che è anche comprensibile. Lo standard sarebbe poco 
lungimirante se enumerasse i sistemi operativi... però tutto sommato 
anche quì il problema è relativo: il makefile deve essere comunque 
"adattato" per la compilazione in una determinata piattaforma e puoi 
specificarlo lì.

 E' garantito che char==byte?
Sě.
*** Azimuth ***

grazie per le risposte... giusto per capirci, ho bisogno di mandare
dei pacchetti UDP ad un server che li accetta solo in un certo modo
(little-big endian) e i valori di una certa dimensione (2-4 byte)
prefissata...
il mio obiettivo era di poter compilare anche sotto linux e dunque il
problema del little-big endian non si porrebbe, poi però ho pensato:
"già che ci sono, perché non rendere tutto compilabile un po'
dovunque?"... ma era giusto uno sfizio, non una necessità...
la necessità, comunque era dovuta al fatto che se un valore deve
essere contenuto in 4 byte, non sono sicuro di usare int, anche perché
forse potrebbe cambiare anche da compilatore a compilatore...
il sapere il sistema operativo mi serviva per la compilazione
condizionale, visto che sicuramente alcune parti di programma
cambierebbero notevolmente da sistema a sistema (ad esempio la
gestione delle immagini... forse anche la gestione delle finestre,
anche se ho intenzione di usare wxWindows, che è portabile)


 forse potrebbe cambiare anche da compilatore a compilatore...
Per quanto riguarda "hton" e "ntoh" ti consiglio "man 3 hton", di cui ti ho
un estratto:
<CITE>
     These macros convert 16-bit and 32-bit quantities to and from the
network
     byte  order  used by the TCP/IP protocols.  The function of the macros
is
     encoded in their name.  H means host byte order,  n  means  network
byte
     order,  s  means  a  16-bit quantity and l means a 32-bit quantity.
Thus
     htons converts a 16-bit quantity from host byte  order  to  network
byte
     order.   The difference between the lower case and upper case variants
is
     that the lower case variants evaluate the argument at most once  and
the
     upper case variants can be used for constant folding.  That is,
</CITE>
Quindi la lunghezza è garantita.
Per la portabilità, ti consiglio di guardare autoconf, il tool di
configurazione portabile.
Ciao!
*** Azimuth ***

> E' garantito che char==byte?
E' garantito dallo standard che sizeof(char) = 1 (cioe' 1 byte), su
qualunque piattaforma.  Cio' che non viene garantita e' la dimensione
in bit del byte.

 certa dimensione. 
ma int32_t non e' standard in C++?
[snip]
ciao

 ma int32_t non e' standard in C++?
No.
E' standard in C (Standard C99, per l'esattezza)
--
Gerolamo

 E' standard in C (Standard C99, per l'esattezza)
grazie

Le specifiche del linguaggio C/C++ non prevedono dimensioni fisse per i tipi
di dato primitivi.
Tuttavia lo standard ANSI richiede la presenza del file limit.h (che ho
puntualmente trovato in ogni compilatore da me utilizzato) in cui sono
definite delle macro che identificano i valori limite (e quindi le
dimensioni) dei tipi primitivi (.
A titolo di esempio allego codice per la definizione di tipi a lunghezza
nota.
N.B.: se operi in C sostituisci i typedef con delle #define.
Spero di esserti stato utile. Ciao!
//**************************************************************************
****
// Definizione dei tipi per i caratteri
//**************************************************************************
****
typedef char  t_char8;
//**************************************************************************
****
// Definizione dei tipi per le stringhe di testo
//**************************************************************************
****
#if defined(UA_STD)
 typedef string C_String8;
#endif //defined(UA_STD)
//**************************************************************************
****
// Definizione dei tipi interi dipendenti dalla piattaforma
//**************************************************************************
****
typedef int    t_int;
typedef unsigned int t_uint;
typedef signed int  t_sint;
typedef float           t_float;
typedef double   t_double;
//**************************************************************************
****
// Definizione dei tipi interi a 8 BIT
//**************************************************************************
****
#if (CHAR_BIT == 8)
# define UA_MAX_UINT8 UCHAR_MAX
# define UA_MIN_SINT8 SCHAR_MIN
# define UA_MAX_SINT8 SCHAR_MAX
 typedef unsigned char t_uint8;
 typedef signed   char t_sint8;
#endif
//**************************************************************************
****
// Definizione dei tipi interi a 16 BIT
//**************************************************************************
****
#if (INT_MAX == 32767)
# define UA_MAX_UINT16 UINT_MAX
# define UA_MIN_SINT16 INT_MIN
# define UA_MAX_SINT16 INT_MAX
 typedef unsigned int t_uint16;
 typedef signed int     t_sint16;
#elif (SHRT_MAX == 32767)
# define UA_MAX_UINT16 USHRT_MAX
# define UA_MIN_SINT16 SHRT_MIN
# define UA_MAX_SINT16 USHRT_MAX
 typedef unsigned short t_uint16;
 typedef signed short t_sint16;
#endif
//**************************************************************************
****
// Definizione dei tipi interi a 32 BIT
//**************************************************************************
****
#if (LONG_MAX == 2147483647L)
# define UA_MAX_UINT32 ULONG_MAX
# define UA_MIN_SINT32 LONG_MIN
# define UA_MAX_SINT32 LONG_MAX
 typedef unsigned long t_uint32;
 typedef signed long     t_sint32;
#elif (INT_MAX == 
2147483647
)
# define UA_MAX_UINT32 UINT_MAX
# define UA_MIN_SINT32 INT_MIN
# define UA_MAX_SINT32 INT_MAX
 typedef unsigned int t_uint32;
 typedef signed int     t_sint32;
#endif

 N.B.: se operi in C sostituisci i typedef con delle #define.
C'e' un motivo particolare?
C:\>iao Angelo
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it