bonjour,
 
une question que je me suis toujours posée:
quel est la différence entre un type  int et un long ???
 

Vu que tu t'es toujours posée la question, t'as jamais pensé à chercher la réponse?  
 
http://www.google.com/search?hl=en [...] f&oq=&aqi=

sizeof(int) <= sizeof(long)
 
Le reste dépend de la plateforme.

Taz question,
 
Le fait que sizeof(int) soit parfois égal à sizeof(long) dépend du compilateur ou de l'architecture ? Parce que j'ai lu des trucs qui disent que sur les CPU 32 bits, les 2 tailles sont pareilles, mais sauf erreur le DSP que j'ai utilisé cette année avait 2 tailles différentes pour les 2.

Et la norme n'aide pas beaucoup, elle dit juste que la taille minimum d'un int, c'est 4 bytes, et que la taille minimum d'un long, c'est 4 bytes aussi.

La norme C89 elle dit ça:

#define INT_MAX                     +32767
#define INT_MIN                     -32767
#define LONG_MAX               +2147483647
#define LONG_MIN               -2147483647

On peut en inférer qu'avec des bytes de 8 bits "int" fait au minimum 2 bytes (et non 4), et long 4. Mais ça reste une inférence.

Il est fréquent que sur les archis 32b INT_MAX soit défini à la même valeur que LONG_MAX (et idem pour les mins), mais c'est une caractéristique de l'implémentation, en ANSI C tu peux pas compter dessus (à noter que depuis le C a gagné "long long", et sur les archis 64b tu te retrouves avec long et long long qui sont identiques, et int qui reste sur l'ancien long )

sur les CPU embarqués 8b et 16b en général on prend 16b comme taille de int  

de toute façon l'idéal pour être sûr de la taille de ses variables quelque soit la plateforme ce sont les type C99:
uint8_t,uint16_t,uint32_t, int8_t... etc..

Tu prends le types.h C89 et tu sais quelle taille font tes variables

oui mais ça change d'une plateforme à l'autre, je parlais pour la portabilité.
 
Aprés tu peux utiliser types.h pour créer tes propres types C99 like mais autant utiliser les normes c'est fait pour

Bah non, le types.h C89 il change pas d'une plateforme à l'autre, ce sont les types.h d'implés qui changent potentiellement. Si tu codes au standard, tu sais de quelle taille sont tes types: tu prends la range définie par le standard

char 8 bits, int 16 bits, long 32 bits

 
De l'ABI.  Les compilateurs respectent généralement une ABI plus ou moins bien spécifiée et la taille des types standards en fait partie.  L'ABI est conçue en fonction de l'architecture et de l'OS -- certains OS prennent même la peine d'en définir une ou plusieurs "standards".  L'exemple le plus visible de la variation est dans les ABI 64 bits:
- int et long sur 64 bit (rare sur des machines non spécialisées)
- int 32 bits et long 64 bits (Unix)
- int et long 32 bits (Windows)

Merci

Personnellement, quand je programme pour Windows, j'évite le int et le long, et j'utilise les types, prédéfinies dans windef.h et basetsd.h, que sont INT32, UINT32, INT64, UINT64, car ces types devraient être stables d'une machine à l'autre et d'une version de Windows à l'autre.

 
D'où le terme plateforme: architecture + compilateur.
 
http://en.wikipedia.org/wiki/64-bit#64-bit_data_models

+1
 
j'ai une autre façon de voir les choses, on en pense ce qu'on veut : j'itère par exemple mes boucles avec des int, je stocke mes indices avec des int, avec le principe que si, sur ma plateforme, int est trop petit pour être un indice (par exemple int 16 bits et indice = 70000), alors cette plateforme n'est pas capable d'acueillir mon programme. Le jour ou vous avez + d'entrées dans un tableau que peut en supporter un registre d'indice, c'est qu'il faut changer d'archi.

 
Il me semble qu'il y a le type "size_t" fait pour les indices des tableaux...

size_t c'est pour les tailles d'objets en général (ce que renvoie sizeof)

Mais oui, cette garantie fait que c'est un bon type pour les indices de tableaux.

http://bytes.com/topic/c/answers/2 [...] post816012