Le type entier permet de mémoriser des nombres entiers. Il existe 4 types permettant de coder des entiers en C. En fonction de la taille des valeurs à mémoriser, il convient de choisir le type approprié :
Type | Octets | Bits | Minimum | Maximum |
---|---|---|---|---|
char | 1 | 8 | -128 | +127 |
short int | 2 | 16 | -32 768 | +32 767 |
int | 4 | 32 | -2 147 483 648 | +2 147 483 647 |
long int | 8 | 64 | -9 223 372 036 854 775 808 | +9 223 372 036 854 775 807 |
Pour les types short int
et long int
, il existe une ecriture courte : short
et long
:
short Var;
long Var = 2;
Il est important de choisir le type le mieux adapté à chaque variable afin d’économiser la mémoire.
Par exemple, si vous utilisez un long
pour mémoriser un nombre entre 1 et 10, vous allez occuper
4 octets alors qu'un seul serait suffisant.
Selon les compilateur et/ou la cible, la taille des types peut varier. Par exemple, si l'on
compile pour une Arduino, un entier sera mémorisé sur 2 octets. Il est possible de connaître la taille
d'un type avec la fonction sizeof()
. Nous verrons un exemple ci-dessous.
Lorsque les types sont précédés du mot-clé unsigned
, cela spécifie que la variable
sera non-signée. En d'autres termes, qu'elle n'aura pas de signe (+
ou -
). La
valeur contenue dans la variable sera nécessairement positive :
Type | Octets | Bits | Minimum | Maximum |
---|---|---|---|---|
unsigned char | 1 | 8 | 0 | 255 |
unsigned short int | 2 | 16 | 0 | 65535 |
unsigned int | 4 | 32 | 0 | 4294967295 |
unsigned long int | 8 | 64 | 0 | +18 446 744 073 709 551 615 |
Les entiers peuvent évidemment être initialisés avec une valeur exprimée en base décimale :
int x = 12;
Il est aussi possible d'initialiser les entiers avec une valeur exprimée en hexadécimale grâce à la syntaxe 0x
:
// On initialise la variable x avec la valeur hexadécimale C (12 en base 10)
int x = 0xC;
Sur la notation des valeurs hexadécimale, le C n'est pas sensible à la case (majuscule ou minuscule) :
int var = 0xA12F;
est identique à :
int var = 0xa12f;
Dans le C standard, il n'est pas possible d'initialiser une variable directement en
base 2. Toutefois, certains compilateurs acceptent la notation 0b
, généralement des
compilateurs dédiés aux systèmes embarqués.
// Cette ligne ne respecte pas les standards du C
// et n'est pas supporté par de nombreux compilateurs
PORTA = 0b10110110;
Pour assurer la compatibilité du code, il est préférable d'éviter cette notation. La meilleure solution est d'initialiser en hexadécimal avec un commentaire approprié comme sur cet exemple :
// | b7 | b6 | b5 | b4 | b3 | b2 | b1 | b0 |
// | 1 | 0 | 1 | 1 | 0 | 1 | 1 | 0 |
PORTA = 0xB6;
Lorsque l'on désire afficher une variable à l'aide de la fonction printf
, il convient
d'utiliser un code de format. Il s'agit d'une séquence spéciale de caractères qui indique à la
fonction que cette séquence devra être remplacée par la variable.
Par exemple, pour afficher la variable N
de type int
, on utilise le code
de format %d
:
int N=12;
printf ("%d", N);
Le tableau ci-dessous synthétise les codes de format pour chaque type :
Type | Code de format |
---|---|
char | %d |
unsigned char | %d ou %u |
short | %i |
unsigned short | %u |
int | %d ou %i |
unsigned int | %u |
long | %ld ou %li |
unsigned long | %lu |
Voici un exemple qui affiche un long int
(10e10
= \( 10^{10} \) ) :
unsigned long N=10e10;
printf ("%lu", N);
Le code ci-dessous permet d'afficher la taille d'un char
et d'un short
. Pour récupérer
la taille d'un type, on utilise l'instruction sizeof()
qui retourne sa taille en octets.
Notez que sizeof()
retourne une valeur comparable à un unsigned long int
, ce qui explique le
code de format %lu
dans le printf
. Compléter le code afin que le programme affiche également
la taille d'un int
et d'un long
.
#include <stdio.h>
int main(void) {
// Taille en octets :
printf("Taille d'un char = %lu octets\n", sizeof(char));
printf("Taille d'un short = %lu octets\n", sizeof(short));
// COMPLETER ICI
return 0;
}
Le code ci-dessous permet d'afficher la taille d'un char
en bits. Compléter
le code ci-dessous afin qu'il affiche également la taille d'un int
et d'un long
.
#include <stdio.h>
int main(void) {
// Taille en bits :
printf("Taille d'un char = %lu bits\n", sizeof(char)*8 );
// COMPLETER ICI
return 0;
}
On fournit le code ci-dessous :
#include <stdio.h>
int main(void) {
// Déclaration et affectation de la variable a
char a=100;
// On ajoute 1 à la variable a
a = a + 1;
// On affiche la valeur de la varaible a
printf("100 + 1 = %d", a);
return 0;
}
char a=127;
.a
pour résoudre le problème.Écrire un programme qui :
nb_student
de type short
nb_student
#include <stdio.h>
int main(void) {
// Déclare et initialise la variable nb_student
// COMPLETER ICI
// Affiche la variable
// COMPLETER ICI
return 0;
}
Pour sauvegarder une valeur dans l'intervalle [-100 ; +100], quel type est le mieux adapté ?
Quel type est le mieux adapté pour mémoriser un code de carte bancaire à 4 chiffres ?
Quel type est le plus adapté pour mémoriser l'âge d'une personne ?
La taille d'un int
est-elle de 4 octets ?
Qu'est-ce qu'un nombre signé ?
Quelle est la plus grande valeur que la variable i
pourra contenir ?
unsigned char i;
unsigned char
est compris entre 0 et 255 (255 = 28 - 1 à cause du zéro).
Essaie encore ...