Les types de base du langage C
Nous vivons dans un monde merveilleux. Lorsque vous voulez manger des pâtes, vous devez mettre de l’eau à chauffer dans une casserole puis utiliser cette eau pour cuire vos pâtes. C’est simple, c’est facile et c’est bon. Mais imaginez un monde dans lequel un contenant (par exemple votre casserole) ne puisse contenir qu’un seule type de contenu (de l’eau ou de l’huile mais pas les deux…). Imaginez donc qu’il existe des vases à eau et des vases a huile. Dans un vase à eau on ne peut verser que de l’eau et dans un vase à huile que… de l’huile ! Dans un tel monde, vous comprenez bien que vous devrez faire attention le jour où on va vous offrir des fleurs car si vous utilisez un vase à huile pour les conserver le résultat risque d’être des plus etranges, voire imprévisible.
Pourquoi est-ce que je raconte cette histoire de monde psycho-rigide un peu étrange ? Tout simplement parce que ce monde existe, et que c’est celui des langages de programmation. Pas de tous les langages de programmation, mais celui des langages de programmation typés (dont fait partie le C bien entendu, sinon ce ne serait pas amusant).
Imaginez que vos contenants soient … des variables, et que vos contenus soient… le contenu de vos variables. Une variable de type entier ne peut contenir que des entiers, une variable de type nombre à virgule ne peut contenir que des nombres à virgule, une variable de type caractère ne peut contenir que des caractères.
Félicitation ! Vous avez compris la notion de type, qui est une notion FONDAMENTALE !!
Mais pourquoi certains langages s’embêtent avec cette notion de type tandis que d’autres (comme le PHP par exemple) s’en fichent éperdument ? Tout simplement parce que tout cela n’est qu’une question de mémoire et d’aide à la programmation. En effet, dans les langages non types, lorsque vous utilisez une variable, le mécanisme de gestion qui se trouve derrière va devoir enregistrer votre variable et va donc devoir déterminer… Le type de votre variable. Ce mécanisme à un coût et votre programme va donc consommer plus de mémoire. Étant donnée la quantité de mémoire dont disposent nos ordinateurs actuels cela n’a presque pas d’importance. Mais dans certains cas, cela devient crucial. Imaginez que vous vous appelez Microsoft, Apple ou Google et que vous souhaitiez réaliser un système d’exploitation qui va justement devoir gérer la mémoire et les applications… Si votre système n’est pas optimisé au milli-poil, vous allez droit dans le mur ! C’est d’ailleurs pour cette raison que K&R on inventé le langage C. Pour concevoir un système d’exploitation.
Vous pourrez me dire qu’il est assez peu probable que vous soyez amenés a réaliser un système d’exploition. C’est vrai. Mais ce qui m’intéresse dans ce cours, c’est de vous apprendre à programmer de sorte que vous compreniez ce qu’est un ordinateur, ce qu’est cette machine merveilleuse. Enfin, j’ai un argument massue : si vous savez programmer avec un langage typé il vous sera aisé d’apprendre à manipuler un langage non typé. L’inverse n’est pas vrai.
Short
Int
Long
Float
Double
Char
Pour chaque type donner la constante min, max
Écrire un programme qui affiche les valeurs de ces constantes.
Expliquer la représentation mémoire des différents types et le principe du débordement.
Expliquer pourquoi ça plante lorsque on fait du transtypage..
Le typage des données
En langage C, chaque variable possède un type. Le type permet la détection d’erreurs, tout en consommant relativement peu de mémoire. Chaque type va nécessiter un certain espace pour enregistrer une donnée. Par exemple, il est fréquent (mais pas garanti) qu’un int soit enregistrés sur 4 octets. Comme nous ne pouvons pas connaitre par coeur le nombre d’octets associé à chaque type de variable, nous allons utiliser l’opérateur sizeof :
Explication : on lui passe en argument un type, par exemple char, int, long ou un type composé et sizeof nous retourne un entier non signé représentant le nombre d’octets qu’une variable de ce type va occuper en mémoire.
site_t est un type défini pour représenter des tailles (par exemple la taille d’une chaine de caractères). Concrètement, il s’agit d’un entier non signé et pur l’utilisation que nous en ferons, nous pouvons considérer qu’il s’agit d’un int ou d’un long.
Voici un petit programme qui va afficher pour différents types de données la taille en octets qu’une donnée de ce type va occuper en mémoire :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
#include <stdio.h> #include <stdlib.h> int main(void) { //printf("sizeof(void) = %d\n", sizeof(void)); printf("sizeof(char) = %d\n", sizeof(char)); printf("sizeof(short) = %d\n", sizeof(short)); printf("sizeof(int) = %d\n", sizeof(int)); printf("sizeof(long) = %d\n", sizeof(long)); printf("sizeof(long long) = %d\n", sizeof(long long)); printf("sizeof(float) = %d\n", sizeof(float)); printf("sizeof(double) = %d\n", sizeof(double)); printf("\nsizeof(void *) = %d\n", sizeof(void *)); printf("sizeof(char *) = %d\n", sizeof(char *)); printf("sizeof(short *) = %d\n", sizeof(short *)); printf("sizeof(int *) = %d\n", sizeof(int *)); printf("sizeof(long *) = %d\n", sizeof(long *)); printf("sizeof(long long *) = %d\n", sizeof(long long *)); printf("sizeof(float *) = %d\n", sizeof(float *)); printf("sizeof(double *) = %d\n", sizeof(double *)); return 0; } |
Et voici l’affichage produit :
Mais attention ! Cet affichage peut tout à fait être différent d’un système à un autre !
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
#include <stdio.h> #include <stdlib.h> #include <limits.h> int main(void) { printf("Nombre de bits dans un char : %21ld\n",CHAR_BIT); printf("\nTaille d'un char : %21d\n",sizeof(char)); printf("Valeur maximum d'un char : %21ld\n",CHAR_MAX); printf("Valeur minimum d'un char : %21ld\n",CHAR_MIN); printf("Valeur maximum d'un char non signe : %21lu\n",UCHAR_MAX); printf("\nTaille d'un short : %21d\n",sizeof(short)); printf("Valeur maximum d'un short : %21ld\n",SHRT_MAX); printf("Valeur minimum d'un short : %21ld\n",SHRT_MIN); printf("Valeur maximum d'un short non signe : %21lu\n",USHRT_MAX); printf("\nTaille d'un int : %21d\n",sizeof(int)); printf("Valeur maximum d'un int : %21ld\n",INT_MAX); printf("Valeur minimum d'un int : %21ld\n",INT_MIN); printf("Valeur maximum d'un int non signe : %21lu\n",UINT_MAX); printf("\nTaille d'un long : %21d\n",sizeof(long)); printf("Valeur maximum d'un long : %21ld\n",LONG_MAX); printf("Valeur minimum d'un long : %21ld\n",LONG_MIN); printf("Valeur maximum d'un long non signe : %21lu\n",ULONG_MAX); printf("\nTaille d'un long long : %21d\n",sizeof(long long)); printf("Valeur maximum d'un long long : %21lld\n",LLONG_MAX); printf("Valeur minimum d'un long long : %21lld\n",LLONG_MIN); printf("Valeur maximum d'un long long non signe : %21llu\n",ULLONG_MAX); return EXIT_SUCCESS; } |
En langage C, le type de base est le char. Pss l’octet, le char ! Ainsi, par définition, la fonction sizeof retourne la taille d’un objet en mémoire en nombre de char… Quelle que soit la taille du type char, qui n’est pas nécessairement indexée sur la taille d’un octet. Pour pouvoir calculer les valeurs maximum et minimum d’un type, il est donc nécessaire de connaitre le nombre de bits contenus dans un char. C’est à cela que sert la constante CHAR_BIT.
