Cours gratuits » Cours informatique » Cours programmation » Cours langage C » Cours Langage C Mémoire et allocation dynamique pdf

Cours Langage C Mémoire et allocation dynamique pdf

Problème à signaler:

Télécharger



★★★★★★★★★★5 étoiles sur 5 basé sur 1 votes.
5 stars
1 votes

Votez ce document:

Cours Langage C Mémoire et allocation dynamique

Intérêts du langage

  • Langage polyvalent permettant le développement de systèmes d'exploitation, de programmes applicatifs scientifiques et de gestion.
  • Langage structuré.
  • Langage évolué qui permet néanmoins d'effectuer des opérations de bas niveau («~assembleur d'Unix~»).
  • Portabilité (en respectant la norme !) due à l'emploi de bibliothèques dans lesquelles sont reléguées les fonctionnalités liées à la machine.
  • e="font-size: 8pt;">Grande efficacité et puissance.

1.3. Qualités attendues d'un programme

  • Clarté
  • Simplicité
  • Modularité
  • Extensibilité  
  1. Généralités

2.1. Jeu de caractères

Le jeu de caractères utilisé pour ecrire une programme est composé de :

  • 26 lettres de l'alphabet (minuscules, majuscules)
  • chiffres 0 à 9
  • séquences d'échappement telles :

o passage à la ligne (\n),

o tabulation (\t),

o backspace (\b).

  • caractères spéciaux :

!  *  +  \  "  <

#  (  =  |  {  >

%  )  ~  ;  ]  /

^  -  [  :  ,  ?

&  _  }  '  .  (espace)

2.2. Structure d'un programme C

  • Un Programme C :

est un fichier source entrant dans la composition d’un programme exécutable est fait d’une succession d’un nombre quelconque d'éléments indépendants, qui sont :

 des directives pour le préprocesseur (lignes commençant par #),

 des constructions de types (struct, union, enum, typedef ),

 des déclarations de variables et de fonctions externes,

 des définitions de variables et

 des définitions de fonctions dont l'une doit s'appeler main et apparaître obligatoirement dans le programme.

  • Une Fonction est formé:

 d’entête (type et nom de la fonction suivis d'une liste d'arguments entre parenthèses),

 instruction composée constituant le corps de la fonction.

  • Instruction composée : délimitée par les caractères { et }
  • Instruction simple : se termine par ;
  • commentaire : encadré par les délimiteurs /* et */
  • Instruction préprocesseur : commence par #

Exemple :

#include<stdio.h>

#define  PI 3.14159

/*  calcul de la surface d'un cercle */

main()

{

  float rayon, surface;

  float calcul(float rayon);

  printf("Rayon = ? ");

  scanf("%f", &rayon);

  surface = calcul(rayon);

  printf("Surface = %f\n", surface);

}

/* définition de fonction */

float calcul(float r)

{

/* définition de la variable locale */

  float a;

  a = PI * r * r;

  return(a);

}

2.3. Compilation et édition des liens

La transformation d’un texte écrit en langage C en un programme exécutable par l’ordinateur se fait en deux étapes : la compilation et l'édition de liens.

La compilation est la traduction des fonctions écrites en C en des procédures équivalentes écrites dans un langage dont la machine peut exécuter les instructions. Le compilateur lit toujours un fichier, appelé fichier source, et produit un fichier, dit fichier objet.

Chaque fichier objet est incomplet, insuffisant pour être exécuté, car il contient des appels de fonctions ou des références à des variables qui ne sont pas définies dans le même fichier. Par exemple, le premier programme que vous écrirez contiendra déjà la fonction printf que vous n’aurez certainement pas écrite vous-même. L'édition de liens est l’opération par laquelle plusieurs fichiers objets sont mis ensemble pour se compléter mutuelle¬ment : un fichier apporte des définitions de fonctions et de variables auxquelles un autre fichier fait référence et réciproquement. L'éditeur de liens (ou linker) prend en entrée plusieurs fichiers objets et bibliothèques (une variété particulière de fichiers objets) et produit un unique fichier exécutable.

2.4. Identificateurs et mots-clés

  • Identificateur :

nom donné aux diverses composantes d'un programme ; variables, constante, tableaux, fonctions.

o Formé de lettres et de chiffres ainsi que du caractère _ permettant une plus grande lisibilité. Le 1er caractère doit obligatoirement être une lettre ou bien le caractère _.

o Peut contenir jusqu'à 31 caractères minuscules et majuscules.

o Les minuscules et les majuscules ne sont pas equivalentes : les identificateurs ligne et Ligne sont différents.

Exemples

  • Identificateurs valides :

x  y12  somme_1  _temperature

noms  surface  fin_de_fichier  TABLE

  • Identificateurs invalides :

4eme  commence par un chiffre

x#y  caractère non autorisé (#)

no-commande  caractère non autorisé (-)

taux change  caractère non autorisé (espace)

  • Mots réservés (mots-clés)

Certains mots sont réservés par le langage car ils ont une signification particulière. Il est alors interdit d'utiliser un de ces mots comme identificateur. Bien que le compilateur fasse la différence entre majuscules et minuscules et qu'on puisse donc utiliser un de ces mots en majuscules comme identificateur, il est préférable, pour la clarté du source, d'éviter cette attitude de programmation.

Types Classes Instructions Autres

char auto break case

double const continue default

float extern do enum

int register else sizeof

long static for typedef

short volatile goto

signed  if

struct  return

union  switch

unsigned  while

void  

2.5. Les séparateurs

Les différents séparateurs reconnus par le compilateur peuvent avoir plusieurs significations.

Type Nom Significations

[…] Crochets Indice d'accès dans un tableau

(...) Parenthèses 1/   Groupement d'expressions (force la priorité)

2/   Isolement des expressions conditionnelles

3/   Déclaration des paramètres d'une fonction

4/   Conversion explicite d'un type (casting)

{….} Accolades 1/   Début et fin de bloc d'instructions

2/   Initialisation à la déclaration d'un tableau

3/   Déclaration d'une structure

, Virgule 1/   Sépare les éléments d'une liste d'arguments

2/   Concaténation d'instructions

; Point virgule Terminateur d'instruction

: Deux points Label

. Point Accède à un champ d'une structure

-> Flèche   ("moins" suivi de "supérieur") Accède à un champ d'un pointeur sur une structure

2.6. Les commentaires

Les commentaires permettent de porter des remarques afin de faciliter la lecture d'un programme source. Chaque commentaire est délimité par les combinaisons suivantes "/* Commentaire */" Les commentaires ne sont pas pris en compte par le compilateur et n'augmentent donc pas la taille des programmes exécutables.

Les commentaires peuvent tenir sur plusieurs lignes du style :

/*  Je commente mon programme Je continue mes commentaires J'ai fini mes commentaires             */

Les commentaires ne peuvent pas être imbriqués comme dans le style :

 /* Début Commentaire 1 /* Commentaire 2 */ Fin commentaire 1*/

Remarque :

Les compilateurs récents acceptent, comme commentaire, la séquence "//" spécifique au langage "C++" qui permet de ne commenter qu'une ligne ou une partie de la ligne.

// Cette ligne est totalement mise en commentaire

int i; // Le commentaire ne commence qu'à la séquence "//"

2.7. Les variables

Comme tout langage déclaratif, le langage C exige que les variables soient déclarées avant leur utilisation. En fait, pour chaque bloc d'instructions délimité par des accolades "{", il faut déclarer toutes les variables avant que soit écrite la première instruction du bloc. Mais cette règle étant valable pour chaque bloc ; on peut aussi déclarer des variables dans des sous-bloc d'instructions.

Exemple :

/* Bloc d'instruction n° 1*/

{

Déclaration des variables (avant toute instruction du bloc n° 1)

Instruction

Instruction

/* Sous-bloc d'instruction n° 2 */

{

Déclaration des variables (avant toute instruction du bloc n° 2)

Instruction

Instruction

}

Instruction appartenant au bloc n° 1

}

Une variable est définie par plusieurs attributs; certains facultatifs mais ayants alors une valeur par défaut) :

 sa classe d'allocation en mémoire ("auto" par défaut)

 en cas de variable numérique, l'indication "signé" ou "non-signé" (signé par défaut)

 le type de la valeur qu'elle doit stocker (entier par défaut, nombre en virgule flottante, etc.)

 son nom (l'identificateur de la variable)

Déclaration :

[classe] [unsigned/signed] <type> <identificateur>; (n'oubliez pas le point-virgule final)

Exemple :

static int nb; // Déclaration d'une variable nb de type int de classe static

int i; // Déclaration d'une variable i de type int (de classe auto par défaut)

Remarque :

la notion de classe sera revue plus en détail par la suite du cours. Jusque là, il suffira de ne pas spécifier de classe pour vos variables.

Lors de sa création en mémoire, une variable possède n'importe quelle valeur.  

  1. Élements de base pour debuter

3.1. Les types de base (types simples ou scalaires)

Un programme manipule des données de différents types sous la forme de constantes ou de variables. Les types de base correspondent aux types directement supportés par la machine. Dans le langage C, tout type de base est un nombre codé sur un ou plusieurs octets. Donc tout type de base accepte toute opération mathématique de base. Les principaux types de base sont:

3.1.1. les entiers

  • int : entier codé sur 2 ou 4 octets suivant la machine sur laquelle on travaille. Dans le monde Unix, il est généralement de 4 octets. Sa plage de valeur peut donc aller de :

 -231 à 231 - 1 ; c'est à dire de -2 147 483 648 à 2 147 483 647 s'il est déclaré signé

 0 à 232 - 1 ; c'est à dire de 0 à 4 294 967 296 s'il est déclaré non-signé

  • short int : entier court codé sur 2 octets. Le mot "short" est suffisant par lui-même donc le mot "int" n'est pas obligatoire. Sa plage de valeur peut aller de :

  -215   à 215  - 1 ; c'est à dire de -32 768 à 32 767 s'il est déclaré signé    

 0 à 216 - 1 ; c'est à dire de 0 à 65 535 s'il est déclaré non-signé

  • long int : entier long codé sur 4 octets. Le mot "long" est suffisant par lui-même donc le mot "int" n'est pas obligatoire. Sa plage de valeur peut aller de :

 -231 à 231 - 1 ; c'est à dire de -2 147 483 648 à 2 147 483 647 s'il est déclaré signé

 0 à 232 - 1 ; c'est à dire de 0 à 4 294 967 296 s'il est déclaré non-signé

  • long long int : entier long codé sur 8 octets. Les mots "long long" sont suffisants par eux-mêmes donc le mot "int" n'est pas obligatoire. Sa plage de valeur peut aller de :

 -263 à 263 - 1 ; s'il est déclaré signé

  0 à 264 - 1 ; c'est à dire de 0 à 18 446 744 073 709 551 615 s'il est déclaré non-signé

  • char : caractère ASCII qui est un nombre entier codé sur 1 octet. Lui aussi de par sa nature numérique accepte des opérations mathématiques. Sa plage de valeur peut aller de :

 -27 à 27 - 1 ; c'est à dire de -128 à 127 s'il est déclaré signé

  0 à 28 - 1 ; c'est à dire de 0 à 255 s'il est déclaré non-signé

Remarques :

Ajouter 1 à une variable ayant atteint sa limite maximale la fait basculer en limite minimale (perte de la retenue). C'est à dire que "127 + 1 = -128" si on travaille sur une variable de type "char signé".  Il est possible de forcer un entier à être signé ou non-signé en rajoutant le mot clef "signed" ou "unsigned" avant son type (char, int, short int, long int). Une variable est signée par défaut donc le mot clef "signed" est inutile.

3.1.2. Les réels

Ils respectent les règles de codage IBM des réels utilisant un bit pour le signe, "x" bits pour la mantisse et "y" pour l'exposant. Ils sont de deux types standard et un troisième non-standard :

 float : réel en virgule flottante codé sur 4 octets. Sa plage de valeur est de :

[+/-]701 411 x 1038  à  [+/-]701 411 x 1038

 double : réel en virgule flottante codé sur 8 octets. Sa plage de valeur est de :

 [+/-]1.0 x 10307  à  [+/-]1.0 x 10307

 long double :Réel en virgule flottante codé sur 12 octets. Sa plage de valeur est de :

 [+/-]3.4 x 10-4932  à  [+/-]1.1 x 104932. Mais ne faisant pas partie de la norme ANSI, il est souvent transformé en "double" par les compilateurs normalisés.

3.1.3. Les booléens

Il n'existe pas en langage C de type booléen. Mais la valeur zéro est considérée par le langage Comme "faux" et toute autre valeur différente de zéro est considérée comme "vrai".

Exemple

#include <stdio.h>

unsigned char mask;

long          val;

main()

{

  unsigned int indice;

  float        x;

  double       y;

  char         c;

        ...

  return;

}

double f(double x)

{

  unsigned short taille;

  int            i;

  unsigned long  temps;

  double         y;

       ...

  return y;

}

3.2. les fonctions d’entrée-sortie (affichage - La saisie)

L'affichage d'une valeur (variable ou constante) se fait en utilisant la fonction "printf( )" qui signifie "print formating"

Cette fonction s'utilise de la manière suivante :

®- Premier argument et le plus complexe : Message à afficher. Ce message, encadré par des " (double guillemets) constitue en fait tout le texte que le programmeur désire afficher. A chaque position du texte où il désire que soit reporté une variable ou une valeur d'expression, il doit l'indiquer en positionnant un signe "%" (pour cent) suivi d'un caractère indiquant la manière dont il désire afficher ladite valeur.

®- Autres arguments : Expressions et variables dont on désire afficher la valeur. Exemple :

main()

{

int a=5;

int b=6;

printf("Le résultat de %d ajouté à %d plus 1 est %d", a, b, a + b + 1);

}

La saisie d'une variable se fait en utilisant la fonction "scan( )" qui signifie "scan formating" Cette fonction s'utilise de la manière suivante :

®- Premier argument et le plus complexe : Masque de saisie. Ce masque, encadré par des " (double guillemets) constitue en fait tout ce que devra taper l'utilisateur quand il saisira ses variables. A chaque position du texte où le programmeur désire que soit reporté une variable à saisir, il doit l'indiquer en positionnant un caractère "%" (pour cent) suivi d'un caractère indiquant la manière dont il désire que soit saisie ladite valeur. Bien souvent, il n'y a aucun masque de saisie car c'est très contraignant.

®- Autres arguments : Variables à saisir, chacune précédée du caractère "&" Exemple :

main()

{

int jj;

int mm; int aa;

printf("Saisissez une date sous la forme jj/mm/aa :\n");

scanf("%d/%d/%d", &jj, &mm, &aa);

}

3.3. Les constantes

Les constantes permettent de symboliser les valeurs numériques et alphabétiques de la programmation courante. Il peut paraître trivial d'en parler tellement on y est habitué mais cela est utile en langage C car il existe plusieurs formats de notation.

  • constantes numériques en base 10 : on les note de la même façon que dans la vie courante. Ex :

5 (cinq) ; -12 (moins douze) ; 17 (dix-sept) ; -45 (moins quarante cinq) ; etc.

  • constantes numériques en base 8 : on les note en les faisant toutes commencer par le chiffre "0". Ex :

05 (cinq) ; -012 (moins dix) ; 017 (quinze) ; -045 (moins trente-sept) ; etc.

  • constantes numériques en base 16 : on les note en les faisant toutes commencer par les caractères "Ox" ou "0X". Ex : ox5 (cinq) ; -0x12 (moins dix-huit) ; 0x17 (vingt-trois) ; -0x45 (moins soixante-neuf) ; etc.

Remarque : il est possible de demander explicitement le codage des constantes précédemment citées sur un format "long" en les faisant suivre de la lettre "l" ou "L". Ex : 5L (nombre "cinq" codé sur 4 octets).

  • constantes ascii : on les notes en les encadrant du caractère ' ' (guillemet simple ou accent aigu). Comme il s'agit d'un code ascii, le langage les remplacera par leur valeur prise dans la table des codes ascii : Ex : 'a' (quatre-vingt dix sept) ; 'A' (soixante-cinq) ; '5' (cinquante-trois) ; etc.
  • constantes code ascii : permettent de coder une valeur ascii ne correspondant à aucun caractère imprimable. On utilise alors un backslash "\" suivi de la valeur ascii convertie en base 8 sur trois chiffres (en complétant avec des zéros si c'est nécessaire) ; ou bien la valeur ascii convertie en base 16 et précédé du caractère "x" ; le tout encadré des caractères "" (guillemet simple ou accent aigu). Ex : '\141 ' (quatre-vingt dix sept ; code ascii de "a"), '\x35' (cinquante-trois ; code ascii de "5") ; etc.
  • constantes en virgule flottante

 notation anglo-saxonne : un nombre avec un "." (point) séparant la partie entière de la partie fractionnelle.

Ex : 3.1416 12.43        -0.38 .38 47. .27

 notation scientifique : un nombre avec un "e" ou un "E" indiquant l'exposant du facteur "10".

Ex : 3e18 (3 x 1018).

4.25E4 4.25e+4 42.5E3

54.27E-32 542.7E-33 5427e-34

.48e13 48.e13 48.0E13

Remarque : toutes les constantes en virgule flottantes sont codées en format "double". Il est cependant possible de demander explicitement le codage de ces constantes sur un format "float" en les faisant suivre de la lettre "f ou "F". Ex : 3.1416F (nombre "3.1416" codé sur 4 octets).

  • constantes prédéfinies : il s'agit de constantes prédéfinies par le compilateur et ayant une fonction spéciale. On utilise la constante telle qu'elle encadrée des caractères "" (guillemet simple ou accent aigu).

Constante Signification Valeur

\n Fin de ligne 10

\t Tabulation horizontale 99

\v Tabulation verticale 11

\b Retour arrière 8

\r Retour chariot 13

\f Saut de page 12

\a Signal sonore 7

\\ Anti slash 92

\" Guillemet 34

\' Apostrophe 44

3.4. Les énumérations de constantes

Les énumérations sont des types définissant un ensemble de constantes qui portent un nom que l'on appelle énumérateur. Elles servent à rajouter du sens à de simples numéros, à définir des variables qui ne peuvent prendre leur valeur que dans un ensemble fini de valeurs possibles identifiées par un nom symbolique.

Syntaxe

enum [nom]

{

   énumérateur1,

   énumérateur2,

   énumérateur3,

       ...

   énumérateurn

};

Les constantes figurant dans les énumérations ont une valeur entière affectée de façon automatique par le compilateur en partant de 0 par défaut et avec une progression de 1. Les valeurs initiales peuvent être forcées lors de la définition.

enum couleurs {noir, bleu, vert, rouge, blanc,jaune};

enum couleurs

{

   noir = -1,

   bleu,

   vert,

   rouge = 5,

   blanc,

   jaune

};

Dans le 1er exemple, les valeurs générées par le compilateur seront :

noir  0  vert  2  blanc  4

bleu  1  rouge  3  jaune  5

et dans le 2e :

noir  -1  vert  1  blanc  6

bleu  0  rouge  5  jaune  7

3.5. Les opérateurs

Les opérateurs permettent de manipuler les variables et les constantes. Ils sont de trois type : ®-  opérateurs unaires : ils prennent en compte un seul élément ®-  opérateurs binaires : ils prennent en compte deux éléments ®-  opérateurs ternaires : ils prennent en compte trois éléments

3.5.1. Opérateurs binaires

Ce sont les plus simples à appréhender. Les premiers peuvent s'appliquer à tout type de variable ou constante (entière ou à virgule flottante) :

 Egal (=) :   Affectation d'une valeur à une variable. Ex : a = 5    , k = j = 6

 Plus (+) :   Addition de deux valeurs. Ex : 13 + 3

 Moins (-) :   Soustraction de deux valeurs. Ex : 13 - 3

 Multiplié (*) :  Multiplication de deux valeurs. Ex : 13 * 3

 Divisé (/) :   Division de deux valeurs. Ex : 13 / 3

 Test d'égalité (==) :

Permet de vérifier l'égalité entre deux valeurs. Ex : a == b (si "a" est égal à "b" alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0"). Attention : Ecrire "=" en pensant "==" peut produire des incohérences graves dans le programme qui se compilera cependant sans erreur !

 Test de différence (!=) :

Permet de vérifier l'inégalité entre deux valeurs. Ex : a != b (si "a" est différent de "b" alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0"). Cet opérateur est l'opposé du "==".

 Tests d'inégalités diverses (>, <, >=, <=) :

Permet de vérifier les grandeurs relatives entre deux valeurs. Ex : a >= b (si "a" est supérieur ou égal à "b" alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0").

Les autres ne peuvent s'appliquer qu'aux valeurs (variables ou constantes) de type entière (char, short, long, int) :

 Modulo (%) :

Reste d'une division entière entre deux valeurs. Ex : 13 % 3

 "ET" logique (&&) :

Opération booléenne "ET" entre deux booléens. Ex : a && b (si "a" est "vrai" ET "b" est "vrai", alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0").

 "OU" logique (||) :

Opération booléenne "OU" entre deux booléens. Ex : a || b (si "a" est "vrai" de "0" OU "b" est "vrai", alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0").

Les suivants ne peuvent s'appliquer qu'aux valeurs (variables ou constantes) de type entière (char, short, long, int) et agiront individuellement sur chaque bit de la constante ou variable.

 "ET" bit à bit (&) :

Opération booléenne "ET" appliquée pour chaque bit des deux valeurs ; le nième bit de la première valeur étant comparé au nième bit de la seconde valeur. Ex : a & 5. Cette expression vaudra "5" si le premier et troisième bits de "a" sont à "1 " (masque).

 "OU" bit à bit (|) :

Opération booléenne "OU" appliquée pour chaque bit des deux valeurs ; le nième bit de la première valeur étant comparé au nième bit de la seconde valeur. Ex : a | 5. Cette expression donnera une valeur où les premier et troisième bits seront toujours à "1".

 "OU EXCLUSIF" bit à bit (^) :

Opération booléenne "OU EXCLUSIF" appliquée pour chaque bit des deux valeurs ; le nième bit de la première valeur étant comparé au nième bit de la seconde valeur. Ex : a ^ 5. Cet expression donnera une valeur où les premier et troisième bits seront à l'inverse de ceux de "a" (bascule).

 Décalage à droite (>>) :

Chaque bit de la valeur sera décalé vers la droite de "x" positions. Ex : 12 >> 3. Cela donne le même résultat que de diviser par 23.

 Décalage à gauche (<<) :

Chaque bit d'une valeur sera décalé vers la gauche de "x" positions. Ex : 12 << 4. Cela donne le même résultat que de multiplier par 24.

3.5.2. Opérateurs d'opération avec affectation

Chaque opérateur binaire précédemment décrit peut être associé à l'opérateur "=" d'affectation. Cela permet de raccourcir une expression du style "a = a + x" par l'expression "a+=x" (sans espace entre le "+" et le "=").

3.5.3. Opérateurs unaires

Une fois que l'on a compris les opérateurs binaires, les opérateurs unaires viennent plus facilement. Les premiers peuvent s'appliquer à tout type de variable ou constante (entière ou à virgule flottante) :

 Moins unaire (-) :   Fait passer en négatif un nombre positif et inversement. Ex : -5

 Plus unaire (+) :   Juste pour assurer la cohérence avec la vie réelle.Ex : +5

 Négation logique ( !) :  Inverse les booléens "vrai" et "faux". Ex : !5

 Taille de (sizeof) :   Renvoie la taille en octet de la valeur ou du type demandé. Ex : sizeof(char)

Le suivant ne peut s'appliquer qu'aux valeurs (variables ou constantes) de type entière (char, short, long, int) et agira individuellement sur chaque bit de la constante ou variable.

 "NOT bit à bit" (~) : Opération booléenne "NOT" appliquée à chaque bit de la valeur.. Ex : ~a. Cet expression donnera une valeur où tous les bits seront à l'inverse de ceux de "a".

Les quatre derniers ne s'appliquent qu'aux variables de type entière (char, short, long, int). Pour chaque exemple, nous prendrons une variable "i" initialement affectée avec "5".

 Pré-incrémentation (++ placé avant la variable) : Ex : ++i ("i" commence par s'incrémenter et passe à "6". Ensuite, l'expression renvoie la valeur finale de "i" ; soit "6").

 Post-incrémentation (++ placé après la variable) : Ex : i++ (l'expression renvoie d'abord la valeur initiale de "i" ; soit "5". Ensuite, "i" s'incrémente et passe à "6").

 Pré-décrémentation (-- placé avant la variable) : Ex : --i ("i" se commence par se décrémenter et passe à "4". Ensuite, l'expression renvoie la valeur finale de "i" ; soit "4").

 Post-décrémentation (-- placé après la variable) : Ex : i-- (l'expression renvoie d'abord la valeur initiale de "i" ; soit "5". Ensuite, "i" se décrémente et passe à "4").

3.5.4. Opérateurs ternaire

Il n'y en a qu'un seul qui peut s'appliquer à tout type de valeur

 vrai…alors…sinon ( ? :) : Ex : x ?y :z (si "x" est différent de "0" donc "vrai" ; alors l'expression complète vaut "y" sinon elle vaut "z").

3.5.5. Valeur et renvoi d'instruction

Toute instruction renvoie une valeur. Exemple, l'instruction "5;" renvoie une valeur qui est… "5". Il est possible, pour ne pas la perdre, de récupérer cette valeur par l'opérateur d'affectation "=" dans l'instruction "a=5;". Mais cette dernière instruction renvoie aussi une valeur qui est… "5". Il est alors encore possible de la récupérer par un nouvel opérateur d'affectation "=" dans l'instruction "b=a=5" ; etc. Il est ainsi possible de récupérer la valeur de chaque instruction écrite. Ex : a=(b == 2) (récupère dans "a" le booléen "vrai" ou "faux" résultant de la comparaison entre "b" et "2").

3.5.6. Opérateur de concaténation

Celui-ci ne s'applique qu'aux instructions

 Concaténation d'instruction (,) : Permet de mettre plusieurs instructions à suivre et de ne prendre que la valeur de la dernière. Ex : int a,b,c=5 (déclare trois variables "a", "b" et "c" de type "int" et affecte "5" à "c").

3.5.7. Exercices

Calculez les résultats des expressions suivantes :

(2 + 3) * 4 /* Réponse : 20 */

(2 << 4) + 3 /* Réponse : 35 */

1 | 3 /* Réponse : 3 */

(2 << 1) > 3 ?25 >> 2 : 25 >> 1 /* Réponse : 6 */

4 > 5 /* Réponse : 0 ("faux") */

2,3,4+5 /* Réponse : 9 (2 et 3 ne sont pas traités) */

  1. LES INSTRUCTIONS DE CONTROLE

Dans un programme, les instructions sont exécutées séquentiellement, c'est-à-dire dans l'ordre où elles apparaissent Or la puissance et le "comportement intelligent" d'un programme proviennent essentiellement :

 de la possibilité d'effectuer des "choix", de se comporter différemment suivant les "circonstances" (celles-ci pouvant être, par exemple, une réponse de l'utilisateur, un résultat de calcul...),

 de la possibilité d'effectuer des "boucles", autrement dit de répéter plusieurs fois un ensemble donné d'instructions.

Ces possibilités sont offertes par des instructions, nommées "instructions de contrôle", permettant de réaliser ces choix ou ces boucles.

 des choix : instructions if...else et switch,

 des boucles : instructions do...while, while et for.


128