Cours 2.2. Les entiers

Le type entier

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.

La taille des types peut varier d'un compilateur à l'autre.

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.

unsigned

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

Initialisation

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;

Affichage

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 réplacé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);

Exercice 1

Le code ci-dessous permet d'afficher la taille d'un char et d'un short. Compléter le code afin qu'il 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;
}

Exercice 2

Le code ci-dessous permet d'afficher la taille d'un char en bits. Compléter le code 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;
}

Exercice 3

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;
}
  1. Analysez et exécutez le code pour le comprendre.
  2. Remplacer la première ligne par char a=127;.
  3. Exécutez le programme, que se passe t-il ?
  4. Changez le type de la variable a pour résoudre le problème.

Exercice 4

Écrire un programme qui :

#include <stdio.h>

int main(void) {
    // Déclare et initialise la variable nb_student

    // COMPLETER ICI

    // Affiche la variable 

    // COMPLETER ICI

    return 0;
}

Quiz

Pour sauvegarder une valeur dans l'intervalle [-100 ; +100], quel type est le mieux adapté ?

Vérifier Bravo ! Le type char est compris entre -128 et +127, c'est suffisant. Essaie encore ...

Quel type est le mieux adapté pour mémoriser un code de carte bancaire à 4 chiffres ?

Vérifier Bravo ! Le code sera entre 0 et 9999, un short est entre -32768 et +32767. Essaie encore ...

Quel type est le plus adapté pour mémoriser l'âge d'une personne ?

Vérifier Bravo ! Ci-dessous, Jeanne Calment, la française doyenne de l'humanité.

Elle est décédée à l'âge de 122 ans. Il n'est pas impossible que l'on atteigne prochainement les 128 ans. Mieux vaut prendre un unsigned char qui n'occupera pas plus de place en mémoire.
Essaie encore ...

La taille d'un int est-elle de 4 octets ?

Vérifier Bravo ! La taille des types peut varier d'un compilateur à l'autre. Essaie encore ...

Qu'est-ce qu'un nombre signé ?

Vérifier Bravo ! Un nombre signé a un signe + ou -. Essaie encore ...

Quelle est la plus grande valeur que la variable i pourra contenir ?

unsigned char i;
Vérifier Bravo ! Un char est compris entre 0 et 255 (255 = 28 - 1 à cause du zéro). Essaie encore ...

Voir aussi


Dernière mise à jour : 20/09/2021