PROGRAMMER EN LANGAGE C

Mme khadija bouzaachane

Introduction

• Bref historique
• Pourquoi utiliser le langage C
• Cycle de développement du programme
• Votre premier programme C

*

Programmer en langage C

2

Introduction : Bref historique

• Le langage C a été créé par Dennis Ritchie aux ‘Bell Telephone Laborateries’ en 1972: il a été conçu pour développer le système Unix.
• En raison de sa puissance et de sa souplesse, le langage C s’est rapidement répandue au-delà des laboratoires Bell.
• Les programmeurs ont commencé à l’utiliser pour écrire toutes sortes de programmes
• Diverses organisations ont utilisé leurs propres versions du langage C. Conséquence : l’implémentation est devenu un casse-tête pour les programmeurs.
• Réponse à ce problème : l’American National Standards Institute(ANSI) à formé un comité en 1983 pour établir le C standard ANSI.

*

3

Programmer en langage C

Introduction

Introduction : Pourquoi utiliser le langage C

• Souple et puissant : Le langage C est utilisé pour des projets variés comme les systèmes d’exploitation, les traitements de textes, les graphiques, les tableurs, les compilateurs pour d’autres langages.
• Il existe un large choix de compilateurs et d’utilitaires.
• Avec la norme ANSI, le C est devenu un langage portable: un programme C écrit pour un type d’ordinateur(IBM) peut être compilé pour tourner sur un autre système avec très peu ou aucune modification.
• Le langage C est modulaire: son code peut(et devrait) être écrit sous forme de sous-programme appelés fonctions. Si vous passez des informations à ces fonctions, vous obtenez un code réutilisable.
• C est un langage structuré (offre plusieurs structures de contrôle) et typé (déclarations obligatoires).

*

4

Programmer en langage C

Introduction

Introduction : Cycle de développement du programme

• Création d’un code source en utilisant un éditeur
• Le code source est une série de commandes qui indiquent à l’ordinateur les tâches que vous voulez lui faire exécuter, il est créé à l’aide d’un éditeur.
• La plupart des systèmes d’exploitation contiennent un éditeur. Sous Unix vous pouvez utiliser, ed, ex, edit emacs ou vi. Microsoft Windows vous offre le bloc-notes.

*

5

Programmer en langage C

Introduction

Introduction : Cycle de développement du programme

• Compilation du code source
• Votre ordinateur ne peut pas comprendre le code source. Il ne peut comprendre que des instructions binaires dans ce que l’on appelle du langage machine. Votre programme C doit être transformé en langage machine pour pouvoir être exécuté sur votre ordinateur. Cette opération est réalisée par un compilateur qui transforme votre fichier code source en un fichier contenant le code objet(les mêmes instructions en langage machine).
• Chaque compilateur possède sa propre commande pour créer le code objet.
• Windows: C Microsoft, Turbo C, Turbo C++, Borland C, Borland C++.
• Unix : utiliser la commande c.
• Linux et Unix: la commande gcc.

​

*

6

Programmer en langage C

Introduction

Introduction : Cycle de développement du programme

• Création du fichier exécutable
• Une partie du langage C est constituée d’une bibliothèque de fonctions contenant du code objet destiné à des fonctions prédéfinies. Ces fonctions sont fournies avec votre compilateur. Si votre programme les utilise, le fichier objet obtenu après compilation doit être complété par le code objet issu de la bibliothèque de fonctions. Cette dernière étape, appelée liaison, fournit le programme exécutable (exécutable signifie que ce programme peut être exécuté sur votre ordinateur)

*

7

Programmer en langage C

Introduction

Introduction : Cycle de développement du programme

*

8

Programmer en langage C

Edition

Compilation

Edition de lien

Programme objet (.obj)

Programme executable (.exe)

Bibliothèques précompilées (.lib)

…………………..

math.lib

Introduction

Introduction : votre premier programme

*

9

Programmer en langage C

#include<stdio.h> Main()

{

printf(‘’Bonjour’’);

}

Affichage

Bonjour

Introduction

Eléments de base du langage C

• Exemple de programme en langage C
• Structure d’un programme en Langage C
• Les mots-clés
• Les types de base
• Déclarations des variables simples

​

​

*

Programmer en langage C

10

Exemple de programme en langage C

#include <stdio.h>//standard input/output

#include <math.h>

#define NFOIS 5

main ()

{ int i;

float x, racx;

printf("Bonjour\n");

printf("je vais vous calculer %d racines carrées\n",NFOIS);

for(i=0;i<NFOIS;i++)

{ printf("donnez un nombre:");

scanf("%f",&x);

if(x<0.0)

printf("le nombre %f ne possède pas de racine carrée\n",x);

else

{ racx=sqrt(x);

printf("le nombre %f a pour racine carrée :%f\n",x,racx);

}

}

printf("travail terminé Au revoir");

}

*

11

Programmer en langage C

Eléments de base du langage C

Programme principal

Bloc

Exemple de programme en langage C

#include<conio.h>

#include<stdio.h>

main()

{ int i,a;

clrscr();

printf("Veuiller introduire un nombre:",a);

scanf("%d",&a);

for(i=a+1;i<=a+10;i++)

{

printf("%d\t",i);

}

getch();

}

*

Programmer en langage C

12

Eléments de base du langage C

Exemple de programme en langage C

#include<conio.h>

#include<stdio.h>

#define a 4

main()

{

clrscr();

gotoxy(4,4);

printf("%d",a );

getch();

}

*

Programmer en langage C

13

Eléments de base du langage C

#include<stdio.h>

#include<conio.h>

main()

{ int i,n,j;

char T[20];

puts("entrer la taille:");

scanf("%d",&n);

for(i=0;i<n;i++)

{

printf("entrer T[%d]=",i);

scanf("%c\n",&T[i]);

getch();

}

*

Programmer en langage C

14

for(i=0;i<n;i++)

{

if(T[i]==T[i+1])

{

for(j=n;j>=i+2;j--)

T[j]=T[j-1];

n++;

T[i+1]='*';

}

}

for(i=0;i<n;i++) printf("%c\t",T[i]);

getch();

}

Structure d’un programme en Langage C

• Les directives à destination du préprocesseur

#include <math.h>

#include <stdio.h>

#define NFOIS 5

• Il s’agit de directive qui seront prises en compte avant la traduction (compilation) du programme. Ces directives doivent être écrites une par ligne, et il est préférable de les placer au début. Les deux premières directives demandent d’introduire(avant compilation) des instructions(en langage C) situées dans les fichier stdio.h et math.h. On les appelles fichiers en-têtes.
• La troisième directive définie une constante. Elle demande de remplacer systématiquement, dans toute la suite du programme, le symbole NFOIS par 5

*

Programmer en langage C

15

Eléments de base du langage C

Programme exécuté automatiquement avant la compilation, il transforme le fichier source à partir d’un certain nombre de directive

Structure d’un programme en Langage C

• La fonction main()
• est un bloc obligatoire d’un programme C. Sa forme la plus simple consiste à saisir son nom, main, suivi de parenthèse () vide et d’une paire d’accolades {}. L’exécution du programme débute à la première instruction de main() et se termine avec la dernière instruction de cette fonction.
• La définition des variables
• Une variable est un nom donné à une zone mémoire pour stocker les données en cours d’exécution. En C une variable doit être définie avant son utilisation. Sa définition indique son nom au compilateur et le type de données que l’on pourra y stocker.
• Sa déclarations est de la forme

Type nom_variable [=<valeur>];

• Elle peut être déclarée à l’extérieur ou à l’intérieur de la fonction main

​

*

Programmer en langage C

16

Eléments de base du langage C

Structure d’un programme en Langage C

• Notion d’identificateur
• Un identificateur, comme son nom l’indique, permet de donner un nom à une entité du programme (qu’il s’agisse d’une variable ou d’une fonction). Ils sont sujets aux règles suivantes :
1. Ils sont formés d’une suite de lettres (’a’ `a ’z’ et ’A’ `a ’Z’), de chiffres (0 à 9) et du signe ’_’. En particulier, les lettres accentuées sont interdites ;
2. le premier caractère de cette suite ne peut pas être un chiffre ;
3. les identificateurs sont case-sensitive.
• Ainsi, les noms var1, S_i, et InitDB sont des identificateurs valides, tandis que i:j ou 1i ne le sont pas.

​

*

Programmer en langage C

17

Eléments de base du langage C

Structure d’un programme en Langage C

• Pour écrire des informations: la fonction printf
• L’instruction printf("Bonjour\n"); appelle une fonction prédifinie(printf) qui reçoit un argument "Bonjour\n"

délimiter par des guillemets pour dire que c’est une chaîne de caractères. La notation \n est conventionnelle : elle représente un caractère de fin de ligne, lorsqu’il est envoyé à l’écran, elle provoque le passage à la ligne suivante.

• L’instruction

printf("je vais vous calculer %d racines carrées\n",NFOIS);

Ressemble à la précédente avec la différence qu’il reçoit un argument que l’on nomme un format, c’est comme un guide qui précise comment afficher les informations, dans notre cas le code format %d précise qu’il s’agit d’un entier.

*

Programmer en langage C

18

Eléments de base du langage C

Structure d’un programme en Langage C

• Pour faire une répétition: l’instruction for
• En langage C, il existe plusieurs façon de réaliser une répétition, comme par exemple : for(i=0;i<NFOIS;i++), son rôle est de répéter le bloc délimiter par les accolades, en respectant les consignes suivantes :
• Avant de commencer cette répétition réaliser : i=0
• Avant chaque nouvelle exécution du bloc, examiner la condition: i<NFOIS, si elle est satisfaite, exécuter le bloc indiqué à sa fin réaliser i++qui n’est que i=i+1
• Pour lire les informations: la fonction scanf
• scanf("%f",&x): cette instruction n’est qu’appel de la fonction prédéfinie scanf dont le rôle est de lire une information au clavier
• %f: le format de la variable
• &x: son adresse

*

Programmer en langage C

19

Eléments de base du langage C

Structure d’un programme en Langage C

• Pour faire le choix: l’instruction if
• Les lignes

if(x<0.0)

printf("le nombre %f ne possède pas de racine carrée\n",x);

else

{ racx=sqrt(x);

printf("le nombre %f a pour racine carrée :%f\n",x,racx);

}

Constituent une instruction de choix basée sur la condition x<0.0, si cette condition est vrai, on exécute l’instruction 1, si elle est fausse on exécute l’instruction 2.

​

​

*

Programmer en langage C

20

Eléments de base du langage C

1

2

Structure d’un programme en Langage C

• Les commentaires
• /* un commentaire d’une ligne*/
• Int a, b, c; /* commentaire sur une partie d’une ligne*/
• /* un commentaire

Qui s’étend sur plusieurs ligne*/

• //cette ligne est en commentaire
• Conseils:
• Ajouter de nombreux commentaires dans le code source de votre programme, surtout s’il contient des instructions ou fonctions qui pourraient être difficile à comprendre. Vous gagner un temps précieux quand vous aurez à le modifier.

*

Programmer en langage C

21

Eléments de base du langage C

Les mots-clés

• Un certains nombres de mots sont réservés pour le langage C, a évité comme identificateurs, la liste exhaustive est la suivante:

​

*

Programmer en langage C

22

Eléments de base du langage C

Les types de base : Les caractères

• On utilise le mot-clé char pour désigner une variable de type char. Il s’agit en fait d’un entier codé sur 8 bits interprété comme un caractère utilisé sur la machine (il s’agit en général du code ASCII de ce caractère).
• Exemple :
• char c1 = ’a’; // Déclaration d’une variable c1 de type char

// a laquelle on affecte la valeur ’a’

// A noter l’utilisation du simple quotte

​

​

*

Programmer en langage C

23

Eléments de base du langage C

Les types de base : Les caractères

• Le tableau suivant donne la liste des principaux codes ASCII en décimal

​

*

Programmer en langage C

24

Eléments de base du langage C

Les types de base : Les caractères

• Caractères particuliers
• Il existe un certain nombre de caractères particuliers dont les principaux sont résumés dans le tableau suivant :

​

​

​

• Chaînes de caractères
• Les chaînes de caractères sont vues comme un pointeur sur des caractères et sont donc de type char *.
• Exemple:
• char * chaine = "Hello World !";// une chaine de caractère

// noter l’utilisation du double

// quotte

​

​

​

*

Programmer en langage C

25

Eléments de base du langage C

Les types de base : Entiers

• Le type int peut être précisé par des attributs :
• De longeur :
• short pour des entiers courts(généralement de 8 ou 16 bits)
• long pour des entiers longs(généralement de 32 ou 64bits)
• La longeur par défaut est généralement de 16 ou 32bits
• De domaine
• signed pour les entiers relatifs
• unsigned pour les entiers naturels positifs ou nuls

​

*

Programmer en langage C

26

Eléments de base du langage C

Les types de base : Entiers

• On utilise le mot-clé int.
• Exemple :
• /* déclaration la plus courante d’une variable de type int */
• int a = 14; // la variable a est initialisée à la valeur 14
• /* Utilisation des précisions (cas le plus général)*/
• short int b; // b est codé sur 16 bits
• int c; // c est codé sur 16 ou 32 bits
• long int d; // d est codé sur 32 bits
• // la possibilité de l’écriture suivante dépend du compilateur
• long long int e; // e est codé sur 64 bits.
• /* Précision du signe */
• unsigned long int n; //n est un entier non signé sur 32 bits

​

​

*

Programmer en langage C

27

Eléments de base du langage C

Les types de base : Entiers

• Le tableau suivant regroupe les types entiers standards avec quelques informations supplémentaires :

​

*

Programmer en langage C

28

Eléments de base du langage C

Les types de base : Entiers

• Constante entière: donnée inchangée qui ne peut varier pendant l’exécution d’un programme
• Déclaration : #define Max 100
• Elle se présente sous forme décimale, octale ou hexadécimal
• décimale (écriture en base 10) : c’est l’écriture usuelle. Ex : 372 ;
• octale (base 8) : on commence par un 0 suivi de chiffres octaux. Ex : 0477 ;
• héxadécimale (base 16) : on commence par 0x (ou 0X) suivis de chiffres héxadécimaux (0-9, a-f). Ex : 0x5a2b, 0X5a2b, 0x5A2b.

​

​

*

Programmer en langage C

29

Eléments de base du langage C

Les types de base : Les flottants

• On distingue trois types de flottants : float, double et long double.
• Exemple : double Pi = 3,14159;
• Le tableau suivant donne des informations pour chaque type flottant.

​

​

*

Programmer en langage C

30

Eléments de base du langage C

Les types de base : Les flottants

• Une constante réelle représente un nombre à virgule flottante(de type float ou double) sous forme décimale ou exponentielle.
• Exemple :

​

*

Programmer en langage C

31

Eléments de base du langage C

Les types de base : Le type void

• Toute variable C est typée, de même que toute valeur de retour d’une fonction. Mais il peut arriver qu’aucune valeur ne soit disponible pour exprimer l’idée de ”aucune valeur”, pour cela on utilise le mot-clé void. Ce type est utilisé pour la déclaration de fonctions qui n’ont pas de valeur de retour.

​

*

Programmer en langage C

32

Eléments de base du langage C

Déclarations des variables simples

• Les variables et les constantes sont les données principales manipulées par un programme.
• Les déclarations introduisent les variables, fixent leur type et parfois aussi leur valeur de départ(initialisation);
• Syntaxe de déclaration:
• int x,y;
• short compteur;
• float prix,salaire;
• double m;
• char s;

​

*

Programmer en langage C

33

Eléments de base du langage C

Déclarations des variables simples

• Initialisation des variables
• En C, il est possible d’initialiser les variables à la déclaration
• Exemples:
• int max=123;
• char tab=‘c’;
• En utilisant l’attribut const, la valeur d’une variable ne change pas au cours du programme: c’est une constante.
• Exemple:
• Const int max=765;
• Const char newline=‘\n’;

*

Programmer en langage C

34

Eléments de base du langage C

Le mot-clé typedef

• Le mot-clé typdef permet de créer un synonyme pour un type de donnée existant. Par exemple l’instruction :
• typedef int entier;

Crée le synonyme entier pour int. Vous pouvez ainsi utiliser entier pour définir des variables de type int, comme dans l’exemple suivant:

• entier compte;

*

Programmer en langage C

35

Eléments de base du langage C

Exercices

• Quel type de variable convient le mieux pour stocker les valeurs suivantes:
• L’âge d’une personne
• Le poids
• Le rayon d’un cercle
• Salaire annuel
• Le prix d’un article
• La note la plus haute d’un test
• La température
• Le gain d’une personne
• La distance d’une étoile en kilomètre

*

Programmer en langage C

36

• unsigned int age;
• unsigned int poids;
• float rayon=3;
• long salaire_annuel;
• float cout=29,95;
• const int note_max=100; #define note_max 100;
• float temperature;
• long gain=30000;
• double distance;

Exercices

• Quels sont les noms de variables correctes :
1. 123variable
2. X
3. Score_totale
4. Poids_en_#s
5. One.0
6. Grand-cout
7. RAYON
8. rayon
9. Cela_est_une_variable_pour_stocker_la_largeur

​

​

​

*

Programmer en langage C

37

�Définition de variables� 

• définition de variables sont couverts par le langage C :
• définition du domaine de valeur de cette variable et les opérations légales sur cette variable ; =⇒ grâce au type.
• réservation de l’espace mémoire nécessaire au support de la variable lors de l’exécution ; =⇒ grâce au type et à la classe mémoire.
• initialisation de la variable à l’aide d’une constante dont le type correspond à celui de la variable ; =⇒ en faisant suivre le nom par un symbole d’affectation = et une valeur compatible avec la variable.
• association d’une durée de vie à la variable qui permet l’utilisation dans certaines parties du programme(règles de visibilité). =⇒ grâce à la classe mémoire et au lieu de définition.

​

*

Programmer en langage C

38

Eléments de base du langage C

Définition de variables : classes mémoires

• Une définition de variable est l’association d’un identifiant à un type et la spécification d’une classe mémoire. La classe mémoire sert à expliciter la visibilité d’une variable et son implantation en machine. Les classes mémoire sont :
• global cette classe est celle des variables définies en dehors d’une fonction. Ces variables sont accessibles à toutes les fonctions. La durée de vie des variables de type global est la même que celle du programme en cours d’exécution.
• Local ou auto : cette classe comprend l’ensemble des variables définies dans un bloc. C’est le cas de toute variable définie à l’intérieur d’une fonction. L’espace mémoire réservé pour ce type de variable est alloué dans la pile d’exécution. C’est pourquoi elles sont appelées aussi auto c.à.d automatique car l’espace mémoire associé est créé lors de l’entrée dans la fonction et il est détruit lors de la sortie de la fonction. La durée de vie des variables de type local est celle de la fonction dans laquelle elles sont définies.

​

​

​

​

*

Programmer en langage C

39

Eléments de base du langage C

Définition de variables : classes mémoires

• Static ce qualificatif modifie la visibilité de la variable, ou son implantation :

– dans le cas d’une variable locale il modifie son implantation en attribuant une partie de l’espace de mémoire globale pour cette variable. Une variable locale de type statique a un nom local mais a une durée de vie égale à celle du programme en cours d’exécution.

– dans le cas d’une variable globale, ce prédicat restreint la visibilité du nom de la variable à l’unité de compilation. Une variable globale de type statique ne peut pas être utilisée par un autre fichier source participant au même programme par une référence avec le mot réservé extern.

• extern ce qualificatif permet de spécifier que la ligne correspondante n’est pas une tentative de définition mais une déclaration. Il précise les variables globales (noms et types) qui sont définies dans un autre fichier source et qui sont utilisées dans ce fichier source.

​

​

*

Programmer en langage C

40

Définition de variables : classes mémoires

• Register ce qualificatif permet d’informer le compilateur que les variables locales définies dans le reste de la ligne sont utilisées souvent. Le prédicat demande de les mettre si possible dans des registres disponibles du processeur de manière à optimiser le temps d’exécution. Le nombre de registres disponibles pour de telles demandes est variable selon les machines. Il est de toute façon limité (4 pour les données, 4 pour les pointeurs sur un 680X0). Seules les variables locales peuvent être qualifiées register.

​

*

Programmer en langage C

41

Définition de variables : classes mémoires

*

Programmer en langage C

42

La syntaxe du langage�

• Instructions, Expressions et Opérateurs
• Les structures de contrôle
• La récursivité
• Les conversions de types
• Principales fonctions d’entrées-sorties standard

​

*

Programmer en langage C

43

Instructions, Expressions et Opérateurs

• Les instructions :
• Une instruction représente une tâche à accomplir par l’ordinateur. En langage C, on écrit une instruction par ligne et elle se termine par un point virgule( à l’exception de #define et #include). Par exemple:

x=2+3;

est une instruction d’affectation. Elle demande à l’ordinateur

d’ajouter 2 et 3 et d’attribuer le résultat à la

variable x.

• Les blocs:
• Un bloc (ou instructions composées) est un groupe d’instructions entre accolades:

​

*

Programmer en langage C

44

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Les expressions:

Une expression est une combinaison d’opérateurs et d’opérandes(variables, constantes). Autrement tout ce qui représente une valeur numérique. Une expression génère toujours un résultat d’un type bien défini qu’on appellera le type de l’expression.

• Les expressions Simples
• L’expression simple est constituée d’une seule variable, d’une constante. Par exemple:
• PI //constante dont la valeur est définie par #define
• Taux //variable
• Les expressions complexes
• Les expressions complexes sont constituées d’expressions plus simples avec des opérateurs. Par exemple:
• 2+8
• 8+(5*taux)+(taux*taux)/cout

​

​

​

​

​

​

*

Programmer en langage C

45

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Les opérateurs: opérateur d’affectation
• L’opérateur d’affectation est le signe(=). Dans le programme C : x=y;

ne signifie pas ‘x égal y’. Elle indique à l’ordinateur ‘d’affecter la valeur de y à x’. Cette instruction doit être composée d’une expression à droite du signe égale, et d’un nom de variable à gauche de ce signe:

variable=expression;

• Exemple:
• x=6+(y=4+5);
• a=b=2;

​

​

​

*

Programmer en langage C

46

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Les opérateurs: opérateur d’affectation
• Opération et affectation combinées op=

var += exp ; équivalent à var = var + (exp) ;

var -= exp ; var = var - (exp) ;

var *= exp ; var = var * (exp) ;

var /= exp ; var = var / (exp) ;

var %= exp ; var = var % (exp) ;

• Attention :

pas d’espace entre l’opérateur op et le égal =,

x *= y+1 est équivalent à x = x*(y+1) et pas x = x*y+1.

​

​

*

Programmer en langage C

47

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs arithmétiques

​

*

Programmer en langage C

48

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs arithmétiques
• Remarques :
• Les opérandes de ces opérateurs arithmétiques peuvent appartenir à tout type arithmétique seul l’opérateur % requiert des types entiers.
• Le résultat d’une division d’entiers est aussi un entier, Exemple :
• 6 / 4 // Resultat: 1
• 6 % 4 // Resultat: 2
• 6.0 / 4.0 // Resultat: 1.5

​

​

​

​

*

Programmer en langage C

49

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs arithmétiques
• Remarques
• Les opérateurs unaires opèrent sur une seule variable ou opérande.
• Concernant l’incrémentation pré/postfixe, voici un petit exemple: Supposons que la valeur de N soit égale à 3 :
• Incrémentation postfixe : X = N++ ;

Résultat : N = 4 et X = 3

• Incrémentation préfixe : X = ++N ;

Résultat : N = 4 et X = 4

• Décrémentation postfixe : X = N-- ;

Résultat : N = 2 et X = 3

• Décrémentation préfixe : X = --N ;

Résultat : N = 2 et X = 2

​

​

​

*

Programmer en langage C

50

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs de comparaison

​

• Toute comparaison est une expression de type int qui renvoie la valeur 0 (faux) ou 1 (vraie). Il faut que les opérandes soient du même type arithmétique (ou des pointeurs sur des objets de même type).
• Attention : il ne faut pas confondre l’opérateur d’égalité (==) avec celui d’affectation (=).
• Les différents opérateurs de comparaison sont détaillés dans le tableau ci-dessous.

​

*

Programmer en langage C

51

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs de comparaison

​

*

Programmer en langage C

52

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs de comparaison

​

#include <stdio.h>

void main ()

{

int x=14,y=1; // x est différent de y

if (x = y) //erreur!!! il faudrait écrire ’if (x == y)’

printf("x est égal à y (%i=%i)\n",x,y);

else

printf("x est différent de y (%i!=%i)\n",x,y);

}

​

*

Programmer en langage C

53

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs logiques

Les opérateurs logiques, permettent de combiner le résultat de

plusieurs expressions de comparaison en une seule expression

logique. Les opérandes des opérateurs logiques peuvent être

n’importe quel scalaire. Toute valeur différente de 0 est interprétée

comme vraie (et 0 correspond à ’faux’). Comme pour les expressions

de comparaisons les expressions logiques renvoient une valeur

entière (0 =faux ; 1=vraie).

Remarque :

les opérateurs && et || évaluent les opérandes de gauche à droite et

le résultat est connu dès l’opérande de gauche. Ainsi, l’opérande de

droite n’est évaluée que si celle de gauche est vraie dans le cas de

l’opérateur && (respectivement fausse dans le cas de l’opérateur ||).

Exemple:

(i < max) && (f(14) == 1), la fonction f n’est appelée que si i < max.

​

​

​

*

Programmer en langage C

54

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs logiques

​

​

​

​

​

​

• Exemples
• L’expression : 32 && 40 vaut 1
• L’expression : !65.34 vaut 0
• L’expression : !!0 vaut 0

​

​

*

Programmer en langage C

55

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs bit à bit

Les opérateurs bits à bits n’opèrent que sur des entiers. Les opérandes sont interprétées bits par bits (le bit 1 correspondant à une valeur vraie, 0 est considéré comme une valeur fausse).

*

Programmer en langage C

56

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs bit à bit
• Exemples: chaque opérande est fournie sous forme décimale et binaire) :

​

​

*

Programmer en langage C

57

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Opérateurs d’accès à la mémoire : &
• L’opérande de l’opérateur d’adresse & doit être une expression qui désigne un objet ou une expression.
• &x renvoie l’adresse mémoire de x et est donc

un pointeur vers x.

​

​

*

Programmer en langage C

58

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Autres opérateurs
• Opérateur séquentiel ( , )
• <expr1> , <expr2>,., <exprN>
• Exprime des calculs successifs dans une même expression. Le type et la valeur de l’expression sont ceux du dernier opérande.
• Exemple : x = 5 , x + 6. L’expression a pour valeur 11
• Opérateur conditionnel (? :)
• <expression> ? <expr1>: <expr2>
• <expression> est évaluée. Si sa valeur est non nulle, alors la valeur de <expr1> est retournée. Sinon, c’est la valeur de <expr2> qui est renvoyée.
• Exemple : max = a > b ? a : b
• si a est le plus grand, alors affectation à max du contenu de a sinon affectation du contenu de b

​

*

Programmer en langage C

59

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Autres opérateurs

​

*

Programmer en langage C

60

La syntaxe du langage C

Instructions, Expressions et Opérateurs

• Priorité et associativité des opérateurs
• Lors de l’évaluation des différentes parties d’une expression, les opérateurs respectent certaines lois de priorité et d’associativité.
• Exemples
• La multiplication a la priorité sur l’addition
• La multiplication et l’addition ont la priorité sur l’affectation.
• Tableau des opérateurs et priorité
• La priorité est décroissante de haut en bas dans le tableau.
• La règle d’associativité s’applique pour tous les opérateurs d’un même niveau de priorité. (pour une associativité de gauche à droite et pour une associativité de droite à gauche).
• Dans une expression, les parenthèses forcent la priorité.

​

*

Programmer en langage C

61

La syntaxe du langage C

Instructions, Expressions et Opérateurs

*

Programmer en langage C

62

La syntaxe du langage C

Exercices

1. Soit les déclarations suivantes :

Int n=10, p=4;

Long q=2;

Float x=1.75;

Donner le type et la valeur de chacune des expressions suivantes

• n+q
• n+x
• n%p+q
• n<p
• q+3 *(n<p)
• x*(q==2)
• x*(q=2)
• (q-2)&&(n-10)
• q&&n

​

*

Programmer en langage C

63

1. long 12
2. float 11,75
3. long 4
4. int 0
5. long 5
6. float 1,75
7. int 0
8. int 1

​

​

La syntaxe du langage C

Exercices

2. n étant de type int, écrire une expression qui prend la valeur :

-1 si n est négatif

0 si n est nul

1 si n est positif

​

*

Programmer en langage C

64

n ? (n>0 ? 1: -1) : 0

La syntaxe du langage C

Les structures de contrôle

• On appelle structure de contrôle toute instruction servant à contrôler le déroulement de l’enchaînement des instructions à l’intérieur d’un programme, ces instructions peuvent être des instructions conditionnelles ou itératives.
•  Parmi les structures de contrôle, on distingue :
• structures de choix
• if….else (choix conditionnel)
• switch (choix multiple)
• structures répétitives ou itérative ou boucle
• for
• while
• do…while
• Branchement inconditionnel
• Break, goto, continue

​

​

​

​

​

*

Programmer en langage C

65

La syntaxe du langage C

Les structures de contrôle : if-else

• La construction if-else (si-sinon) est la construction logique de base du langage C qui permet d'exécuter un bloc d'instructions selon qu'une condition est vraie ou fausse.
• Syntaxe
• Forme 1
• if (expression) instruction-1;

la forme if est ici dans sa forme la plus simple. Si expression est vraie, instruction-1 est exécutée. Si expression est fausse, instruction-1 est ignorée.

​

*

Programmer en langage C

66

La syntaxe du langage C

Les structures de contrôle : if-else

• Syntaxe
• Forme 2
• if (expression) instruction-1;

else instruction-2;

Si expression est vraie, instruction-1 est exécutée, sinon c’est instruction-2 qui est

exécutée.

• Forme 3
• if (expression-1)

instruction-1;

else if (expression-2)

instruction-2;

else

instruction-3;

Les instructions if sont imbriquées. Si expression-1 est vraie, instruction-1

est exécutée. Dans le cas contraire expression-2 est évaluée si cette dernière est

vraie instruction-2 est exécutée. Si les deux expressions sont fausses, c’est

instruction-3 qui est exécuté

​

​

​

​

​

​

*

Programmer en langage C

67

La syntaxe du langage C

Les structures de contrôle : if-else

• Exemples:
• Exemple 1
• if (salaire >45.000)

tax=0.30;

else

tax=0.25;

• Exemple 2
• if (age <18)

printf(‘’mineur’’);

else if (age <65)

printf(‘’adulte’’);

else

printf(‘’personne agée’’);

​

​

*

Programmer en langage C

68

La syntaxe du langage C

Les structures de contrôle : if-else

#include <stdio.h>

void main ()

{ int i;

printf("Tapez un nombre entier positif ou negatif: ");

scanf("%d", &i);

if (i<0) {

i=-i;

printf("J'ai remis i à une valeur positive.\n");

}

else {

printf("Vous avez tapé un nombre positif.\n");

}

}

*

Programmer en langage C

69

Les structures de contrôle : Switch

• L’instruction switch est l’instruction de contrôle la plus souple du langage C. Elle permet à votre programme d’exécuter différentes instructions en fonction d’une expression qui pourra avoir plus de deux valeurs.
• On l’appelle aussi l’instruction d’aiguillage. Elle teste si une expression prend une valeur parmi une suite de constantes, et effectue le branchement correspondant si c’est le cas.

​

*

Programmer en langage C

70

La syntaxe du langage C

Les structures de contrôle : Switch

• Syntaxe

​

switch (<condition>) {

case <valeur 1> : <action 1>; break;

case <valeur 2> : <action 2>; break;

…

default : <action n>;

}

​

*

Programmer en langage C

71

La syntaxe du langage C

Les structures de contrôle : Switch

• Remarques :
• Le fonctionnement de cette instruction est le suivant :
• expression est évaluée ;
• s’il existe un énoncé case avec une constante qui est égale à la valeur de l’expression, le contrôle est transféré à l’instruction qui suit cet énoncé;
• si un tel case n’existe pas, et si énoncé default existe, alors le contrôle est transféré à l’instruction qui suit l’énoncé default ;
• si la valeur de l’expression ne correspond à aucun énoncé case et s’il n’y a pas d’énoncé default, alors aucune instruction n’est exécutée.
• Attention.
• Lorsqu’il y a branchement réussi à un case, toutes les instructions qui le suivent sont exécutées, jusqu’à la fin du bloc ou jusqu’à une instruction de rupture (break).

​

*

Programmer en langage C

72

La syntaxe du langage C

Les structures de contrôle : Switch

#include<stdio.h>

void main() {

int a,b,d;

char operateur;

Printf(‘’ Entrez un opérateur (+, -,* ou /):’’);

Scanf(‘’%c’’,&operateur);

Printf(‘’ Entrez deux entiers:’’);

Scanf(‘’%d’’,&a); Scanf(‘’ %d’’,&b);

switch(operateur){

case’-’ : y=a-b; printf(‘’%d’’,y);break;

case’+’ : y=a+b; printf(‘’%d’’,y); break;

case’*’ : y=a*b; printf(‘’%d’’,y); break;

case’/’ : y=a/b; printf(‘’%d’’,y); break;

default : printf(‘’opérateur inconnu\n’’);break;

}

}

*

Programmer en langage C

73

La syntaxe du langage C

Les structures de contrôle : while

• L’instruction while permet de répéter des instructions, tant qu'une condition est vérifiée.
• Syntaxe
• Forme 1

while (condition)

une-instruction;

• Forme 2

while (condition) {

Des instructions;

}

}

​

​

*

Programmer en langage C

74

La syntaxe du langage C

Les structures de contrôle :while

• La boucle while fonctionne de la façon suivante:
1. La condition est évaluée,
2. si cette condition est fausse, l’instruction while se termine,
3. si la condition est vraie les instructions sont exécutées
4. l’exécution reprend à l’étape 1.
• Exemple

#include <stdio.h>

void main ()

{ int i=1, N;

printf("N=\n"); scanf("%d",&N);

while (i <= N) {

printf("%d ", i); i = i+1;}

printf("\n");

}

​

​

*

Programmer en langage C

75

La syntaxe du langage C

Les structures de contrôle :while

• while imbriqué

#define MAX 4

int i=0,j;

while (i < MAX ) {

j=0;

while (j < MAX ) {

printf(" position : %d \t %d\n",i,j);

j++;

}

i++;

}

​

*

Programmer en langage C

76

La syntaxe du langage C

Les structures de contrôle : do-while

• L'instruction do-while, exécute le bloc d'instructions tant qu’une condition reste vraie. Dans cette boucle le test de la condition s’effectue à la fin de la boucle.
• Syntaxe
• Forme 1

do

une-instruction;

while (condition)

• Forme 2

do {

Des instructions;

} while (condition)

​

*

Programmer en langage C

77

La syntaxe du langage C

Les structures de contrôle : do-while

• Exemple :

#include <stdio.h>

#define MAX 4

void main()

{

int i=MAX;

do {

printf("Valeur de i : %i\n",i);

i++;

} while (i < MAX);

}

​

*

Programmer en langage C

78

La syntaxe du langage C

Les structures de contrôle : for

• A l’instar des instructions while et do-while l’instruction for permet d’exécuter un certain nombre de fois un bloc d’une ou plusieurs instructions.
• Syntaxe:
• for( [expression1] ; [expression2] ; [expression3 ])

{

liste d’instructions

}

• Les crochets [ et ] signifient que leur contenu est facultatif
• Dans la construction de for :
• expression1 : effectue les initialisations nécessaires avant l’entrée dans la boucle;
• expression2 : est le test de continuation de la boucle ; le test est évalué avant l’exécution du corps de la boucle;
• expression3 : est évaluée à la fin du corps de la boucle.

*

Programmer en langage C

79

La syntaxe du langage C

Les structures de contrôle : for

• Remarques
• En pratique, expression1 et expression3 contiennent souvent plusieurs initialisations séparées par des virgules.
• For(i=0,j=1,k=5;….;…)
• Les expressions expression1 et expression3 peuvent être absente(les points-virgules doivent apparaître.
• i=1; for(;i<=5;) {printf(‘’%d fois\n’’,i);i++;}
• Lorsque expression2 est absente, l’expression correspondante est considérée comme vraie. Par conséquent, for(;;) est une boucle infinie

*

Programmer en langage C

80

La syntaxe du langage C

Les structures de contrôle : for

• Remarques :par définition l’instruction de for

for ( expression1 ; expression2 ; expression3 )

{

liste d’instructions

}

est équivalente à

expression1;

while(expression2)

{

instructions;

expression3;

}

*

Programmer en langage C

81

La syntaxe du langage C

Les structures de contrôle :for

• Exemples
• Programme pour calculer la somme de 1 à 100

Int n,total;

For(total=0,n=1;n<=100;n++)

total+=n;

Printf(’’la sommes des nombres de 1 à 100 est %d\n’’,total);

​

• Programme pour calculer la factorielle d’un entier n:

Int n, i,fact;

For(fact=1,i=1;i<=n;i++)

fact*=i;

Printf(’’%d!= %d\n’’,n,fact);

​

​

*

Programmer en langage C

82

La syntaxe du langage C

Les structures de contrôle : break, goto et continue

• Instruction break
• On a vu le rôle de l’instruction break; au sein d’une instruction de branchement multiple switch.
• L’instruction break peut, plus généralement, être employée à l’intérieur de n’importe quelle boucle (for ; while ; do-while). Elle permet l’abandon de la structure et le passage à la première instruction qui suit la structure.
• En cas de boucles imbriquées, break fait sortir de la boucle la plus interne.

*

Programmer en langage C

83

La syntaxe du langage C

Les structures de contrôle : break, goto et continue

• Instruction break : exemple

#include <stdio.h>

void main( )

{ int i;

for (i = 1 ; i<=10 ; i++){

printf(’’début tour %d\n’’ ,i) ;

printf(’’ bonjour\n’’);

if (i ==3) break ;

printf(" fin tour%d\n", i) ;

}

printf(" après la boucle\n") ;

}

*

Programmer en langage C

84

La syntaxe du langage C

Evaluation:

Début tour 1

Bonjour

Début tour 2

bonjour

fin tour 2

Début tour 3

Bonjour

Après la boucle

​

Les structures de contrôle : break, goto et continue

• Instruction continue
• L’instruction continue peut être employée à l’intérieur d’une structure de type boucle (for ; while ; do-while ).
• Elle produit l’abandon de l’itération courante et fait passer directement à l’itération suivante d’une boucle.
• L’instruction continue concerne la boucle la plus proche.

*

Programmer en langage C

85

La syntaxe du langage C

Les structures de contrôle : break, goto et continue

• Instruction continue
• Exemple :

Void main()

{ int i;

for(i=1;i<=10;i++)

{ printf(’’début tour %d\n’’ ,i) ;

if (i <4) continue ;

printf(’’ bonjour\n’’);

}

}

*

Programmer en langage C

86

La syntaxe du langage C

Evaluation:

Début tour 1

Début tour 2

Début tour 3

Début tour 4

Bonjour

Début tour 5

Bonjour

​

Les structures de contrôle : break, continue et goto

• Instruction goto
• Elle permet le branchement en un emplacement quelconque du programme.

Void main()

{ int i;

for(i=1;i<=10;i++)

{ printf(’’début tour %d\n’’ ,i) ;

printf(’’ bonjour\n’’);

if (i ==3) goto sortie ;

printf(’’ fin tour%d\n", i);

}

Sortie:printf (" après la boucle\n") ;

}

​

*

Programmer en langage C

87

La syntaxe du langage C

Evaluation:

Début tour 1

Bonjour

fin tour 1

Début tour 2

bonjour

fin tour 2

Début tour 3

Bonjour

Après la boucle

​

La récursivité

• Le langage C autorise des appels de fonctions. Celle-ci peut prendre deux aspects:
• Récursivité directe: une fonction comporte, dans sa définition, au moins un appel à elle-même.
• Récursivité croisée: l’appel d’une fonction entraîne celui d’une autre fonction qui, à son tour, appelle la fonction initiale(le cycle pouvant d’ailleurs faire intervenir plus de deux fonctions)

*

Programmer en langage C

88

La syntaxe du langage C

La récursivité

• Exemple

#include <stdio.h>

int fact (int x)

{ printf (“Computing fact %d\n”, x) ;

if (x == 1)

return 1 ;

else

return x * fact (x-1) ;

}

Void main (){

printf (“5! = %d\n”, fact (5)) ;

}

*

Programmer en langage C

89

La syntaxe du langage C

Les conversions de types

• La conversion de type est un outil très puissant, elle doit donc être utilisée avec prudence. Le compilateur fait de lui-même des conversions lors de l’évaluation des expressions. Pour cela il applique des règles de conversion implicite. Ces règles ont pour but la perte du minimum d’information dans l’évaluation de l’expression. Ces règles sont les suivantes:
• Règle de Conversion Implicite
• Convertir les éléments de la partie droite d’une expression d’affectation dans le type de la variable ou de la constante le plus riche.
• Faire les opérations de calcul dans ce type.
• Puis convertir le résultat dans le type de la variable affectée.

*

Programmer en langage C

90

La syntaxe du langage C

Les conversions de types

• La notion de richesse d’un type est précisée dans la norme [ISO89]. Le type dans lequel le calcul d’une

expression à deux opérandes doit se faire est donné par les règles suivantes :

• si l’un des deux opérandes est du type long double alors le calcul doit être fait dans le type long double ;
• sinon, si l’un des deux opérandes est du type double alors le calcul doit être fait dans le type double ;
• sinon, si l’un des deux opérandes est du type float alors le calcul doit être fait dans le type float ;
• si l’un des deux opérandes est du type unsigned long int alors le calcul doit être fait dans ce type ;
• si l’un des deux opérandes est du type long int alors le calcul doit être fait dans le type long int ;

*

Programmer en langage C

91

La syntaxe du langage C

Les conversions de types

• Hiérarchie des conversions arithmétiques habituelles est la suivante:

*

Programmer en langage C

92

La syntaxe du langage C

La syntaxe du langage C

long double

double

Float

unsigned long long

long long

unsigned long

long

unsigned int

int

​

Les conversions de types

• Conversion implicite
• Il est possible de forcer la conversion d’une variable (ou d’une expression) dans un autre type avant de l’utiliser par une conversion implicite. Cette opération est appelée “cast”. Elle se réalise de la manière suivante :

(type) expression

• Prenons pour exemple l’expression : i = (int) f + (int) d ;
• f et d sont convertis en int, puis additionnés. Le résultat entier est rangé dans i.

*

Programmer en langage C

93

La syntaxe du langage C

Les conversions de types

• Exemple

​

*

Programmer en langage C

94

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• Il s’agit des fonctions de la librairie standard stdio.h utilisées avec les unités classiques d’entrées-sorties, qui sont respectivement le clavier et l’écran.
• Ces fonctions sont:
• Getchar
• Putchar
• Puts
• Printf
• scanf

​

*

Programmer en langage C

95

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction getchar
• La fonction getchar permet la récupération d’un seul caractère à partir du clavier. La syntaxe d’utilisation de getchar est la suivante : var=getchar();
• Notez que var doit être de type char. Exemple :

#include <stdio.h>

void main() {

char c;

printf("Entrer un caractère:");

c = getchar();

printf("Le caractère entré est %c\n",c);

}

*

Programmer en langage C

96

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction putchar
• permet l’affichage d’un seul caractère sur l’écran de l’ordinateur. putchar constitue alors la fonction complémentaire de getchar. La syntaxe d’utilisation est la suivante : putchar(var);
• où var est de type char. Exemple :

#include <stdio.h>

Void main() {

char c;

printf("Entrer un caractère:");

c = getchar();

putchar(c);

}

*

Programmer en langage C

97

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction puts
• Syntaxe : puts(ch);
• Cette fonction affiche, sur stdout, la chaîne de caractères ch puis positionne le curseur en début de ligne suivante. puts retourne EOF en cas d’erreur.
• Exemple :

#include <stdio.h>

void main() {

char * toto = "on est super content!";

puts(toto);

}

*

Programmer en langage C

98

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction d’écriture à l’écran formattée printf
• La fonction printf est une fonction d’impression formatée, ce qui signifie que les données sont converties selon le format particulier choisi. Sa syntaxe est la suivante :

printf("chaîne de contrôle", expression₁, . . . , expression_n);

• La chaîne de contrôle contient le texte à afficher et les spécifications de format correspondant à chaque expression de la liste. Les spécifications de format ont pour but d’annoncer le format des données à visualiser. Elles sont introduites par le caractère %. Le i-ème format de la chaîne de contrôle sera remplacé par la valeur effective de expression_i.

*

Programmer en langage C

99

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction d’écriture à l’écran formattée printf
• Les différents formats de la fonction printf

​

​

*

Programmer en langage C

100

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction d’écriture à l’écran formattée printf
• Les différents formats de la fonction printf

​

*

Programmer en langage C

101

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction d’écriture à l’écran formattée printf
• Les différents formats de la fonction printf
• Exemple

printf("|% d|\n",14); | 14|

printf("|% d|\n",-14); |-14|

printf("|%x|\n",0x56ab); |56ab|

printf("|%X|\n",0x56ab); |56AB|

printf("|%o|\n",14); |16|

printf("|%#o|\n",14); |016|

printf("|%10d|\n",14); | 14|

printf("|%f|\n",1.234567890123456789e5); |123456.789012|

printf("|%.4f|\n",1.234567890123456789e5); |123456.7890|

​

​

*

Programmer en langage C

102

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction d’écriture à l’écran formattée printf
• Les différents formats de la fonction printf
• Exemple

printf("|%e|\n",1.234567890123456789e5); |1.234568e+05|

printf("|%.4e|\n",1.234567890123456789e5); |1.2346e+05||

printf("|%.4g|\n",1.234567890123456789e-5); |1.235e-05|

printf("|%.4g|\n",1.234567890123456789e-3); |0.001235|

printf("|%.8g|\n",1.234567890123456789e5); |123456.79|

*

Programmer en langage C

103

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction de saisie scanf
• La fonction scanf permet de récupérer les données saisies au clavier, dans le format spécifié. Ces données sont stockées aux adresses spécifiées par les arguments de la fonction scanf (on utilise donc l’opérateur d’adressage & pour les variables scalaires). scanf retourne le nombre de valeurs effectivement lues et mémorisées .La syntaxe est la suivante :

scanf("chaîne de contrôle", arg1, . . . , argn);

• La chaîne de contrôle indique le format dans lequel les données lues sont converties. Comme pour printf, les conversions de format sont spécifiées par un caractère précédé du signe %.

*

Programmer en langage C

104

La syntaxe du langage C

Principales fonctions d’entrées-sorties standard

• La fonction de saisie scanf
• Exemple

#include <stdio.h>

void main()

{

int i ;

printf("entrez un entier sous forme hexadecimale i = ");

scanf("%x",&i);

printf("i = %d\n",i);

}

​

*

Programmer en langage C

105

La syntaxe du langage C

Les Types Dérivés

• Les Enumération
• Les Tableaux
• Les Structures
• Les Unions

*

Programmer en langage C

106

Les énumérations

• Les énumérations permettent de définir un type pour des variables qui ne sont affectées qu’a un nombre fini de valeurs. Un objet de type énumération est défini par le mot-clef enum et un identificateur de modèle, suivi de la liste des valeurs que peut prendre cet objet :

enum modele {constante₁, constante₂,. . . ,constante_n} ;

• En réalité, les objets de type enum sont représentés comme des int. Les valeurs possibles constante₁, constante₂,. . . ,constante_n sont codées par des entiers de 0 à n-1.

*

Programmer en langage C

107

Les types dérivés

Les énumérations

• Le type enum boolean, Dans l’exemple suivant, associe l’entier 0 à la valeur FALSE et l’entier 1 à la valeur TRUE.

#include <stdio.h>

enum boolean {FALSE, TRUE};

void main ()

{

enum boolean b1 = TRUE;

printf("b = %d\n",b1);

}

*

Programmer en langage C

108

Les types dérivés

Les tableaux

• Il est souvent nécessaire de mémoriser un grand nombre d’éléments identiques. Il serait par exemple fastidieux de déclarer 1000 variables réelles représentant 1000 valeurs. Pour cela on utilise des tableaux.
• Définition
• Un tableau représente un ensemble d’emplacements mémoire qui portent le même nom et contiennent le même type de données. Chacun de ces emplacements est un éléments du tableau.
• On appelle tableau une variable composée de données de même type, stockée de manière contiguë en mémoire(les uns à la suite des autres).
• Un tableau est une suite des éléments de même taille. Par conséquent, la taille(en octet) du tableau est :

type de donnée*le nombre d’éléments.

*

Programmer en langage C

109

Les types dérivés

Les tableaux

• Les tableaux à une dimensions
• Un tableau à une dimension ne possède qu’un index. Un index est le nombre entre crochets qui suit le nom du tableau. Il indique le nombre d’éléments du tableau.
• Déclarations

<type simple> Nom_du_tableau[nombre_elements];

• Type simple : définit le type d’élément que contient le tableau
• Nom du tableau : est le nom qu’on donne au tableau, ce nom suit les mêmes règles qu’un nom de variable.
• Nombre_elements : est une expression constante entière positive, qui exprime la taille du tableau.
• Exemple:
• char caractere[12];
• int entier[10];
• float reel[8];

​

*

Programmer en langage C

110

Les types dérivés

Les tableaux

• Les tableaux à une dimensions
• Initialisation à la déclaration

Il est possible d’initialiser le tableau à la définition :

<type > Nom_du_tableau[nombre_elements]={c1,c2,…cn};

Ou c1, c2,…cn sont des constantes dont le nombre ne doit pas dépasser le nombre _elements.

• Exemple

#define Mois 12

int tableau[12];

int tab[4] ={100,200,300,400;}\\ initialisation

char voyelles[6]={‘a’,’e,’i’,’o’,’u’,’y’};

​

*

Programmer en langage C

111

Les types dérivés

Les tableaux

• Les tableaux à une dimensions
• Accès aux composantes d’un tableau
• Pour accéder à un élément du tableau, il suffit de donner le nom du tableau, suivi de l’indice de l’élément entre crochets :

Nom_du_Tableau [indice]  

• Où indice est une expression entière positive ou nulle.
• Un indice est toujours positif ou nul ;
• L’indice du premier élément du tableau est 0 ;
• L’indice du dernier élément du tableau est égal au nombre d’éléments – 1.
•  Exemples :
• short A[5] = {12 , 23 , 34 , 45 , 56}; // A[0] = 12 ; A[1] = 23 ; A[2] = 34 ;

// A[3] = 45 ; A[4] = 56 ;

• for( i = 0 ; i< 5 ; i++ ) //Affichage des éléments

printf(‘’A[%d] = %d \t‘’,i,A[i)); // du tableau A

*

Programmer en langage C

112

Les types dérivés

Les tableaux

• Les tableaux à une dimensions
• Remarque
• Chaque élément ( TAB[i] ) d’un tableau ( int TAB[20] ) est manipulé comme une simple variable, on peut :
• la lire : scanf("%d", &TAB[i] ); // TAB[i] sera initialisé par un

// entier saisi depuis la clavier

• l’écrire : printf("TAB[%d] = %d", i , TAB[i] ); //Le contenu de TAB[i]

//sera affiché sur écran

• la passer en argument à une fonction : TAB[i] = pow(TAB[i],2);

// = TAB[i] ²

• Pour initialiser un tableau (TAB1) par les éléments d’un autre tableau (TAB2) : évitez d’écrire TAB1 = TAB2 (incorrect)
• On peut par exemple écrire :

for( i = 0 ; i < taille_tableau ; i++ )

TAB1[i] = TAB2[i];

• �

​

​

*

Programmer en langage C

113

Les types dérivés

Les tableaux

• Les tableaux à deux dimensions
• En C, un tableau multidimensionnel est considéré comme un tableau dont les éléments sont eux même des tableaux.
• Un tableau à deux dimensions se déclare donc de la manière suivante :

int mat[10][20];

• En faisant le rapprochement avec les mathématiques, on peut dire que mat est une matrice de 10 lignes et de 20 colonnes.

​

​

*

Programmer en langage C

114

Les types dérivés

Les tableaux

• Les tableaux à deux dimensions
• On accède à un élément du tableau par l’expression mat[i][j].
• Pour initialiser un tableau à plusieurs dimensions à la compilation, on utilise une liste dont chaque élément est une liste de constantes :

#include <stdio.h>

#define L 3 //nombre de lignes

#define C 2 //nombre de colonnes

short tab[L][C] = {{1, 2}, {14, 15}, {100, 200}};

void main() {

int i, j;

for (i = 0 ; i < L; i++) {

for (j = 0; j < C; j++)

printf("tab[%d][%d]=%d\n",i,j,tab[i][j]);}}

​

​

*

Programmer en langage C

115

Les types dérivés

Les tableaux

• Modification des éléments d’un tableau passé en paramètre

#include <stdio.h>

void print_tab(int tab[], int nb_elem) {...}

/* incrémente chaque composantes du tableau */

void incr_tab(int tab[], int nb_elem) {

int i;

for (i=0; i < nb_elem; i++) tab[i]++;}

#define TAILLE 4

void main() {

int t[TAILLE] = {1, 2, 3, 4};

incr_tab(t, TAILLE);

print_tab(t, TAILLE);}

​

*

Programmer en langage C

116

Les types dérivés

Les structures

• Une structure est une suite finie d’objets de types différents. Qui sont regroupé au sein d’une même entité.
• Contrairement aux tableaux, les différents éléments d’une structure n’occupent pas nécessairement des zones contiguës en mémoire.
• Chaque élément de la structure, appelé membre ou champ, est désigné par un identificateur.

struct enreg {

int numero;

int qte;

float prix;

};

​

*

Programmer en langage C

117

Les types dérivés

Les structures

• L’utilisation pratique d’une structure se déroule de la façon suivante :
1. On commence par déclarer la structure elle-même. Le modèle général de cette déclaration est le suivant :

struct nom_structure {

type_1 membre_1 ;

type_2 membre_2 ;

...

type_n membre_n ;

} ;

​

*

Programmer en langage C

118

Les types dérivés

Les structures

2. Pour déclarer un objet de type structure correspondant au modèle

précédent, on utilise la syntaxe :

struct nom_structure identificateur_objet ;

Ou bien, si le modèle n’a pas encore été déclaré au préalable :

struct nom_structure {

type_1 membre_1 ;

type_2 membre_2 ;

...

type_n membre_n ;

} identificateur_objet ;

3. On accède aux différents membres d’une structure grâce à

l’opérateur membre de structure, noté ”.”. Le i-ème membre de objet

est désigné par l’expression :

identificateur_objet.membre_i

​

*

Programmer en langage C

119

Les types dérivés

Les structures

• Chaque champ d’une structure peut être manipulé comme n’importe quelle variable de type correspondant. Voici quelques exemples utilisant la structure enreg:

​

• Struct enreg art1,art2; /* déclaration*/
• Art1.numero=15; /*affectation*/
• Printf(‘’%f’’,art1.prix); /* affiche la valeur du champ prix*/
• Scanf(‘’%f’’,&art2.prix); /*lit une valeur qui sera affecté

au champ prix de la structure art2 */

• Art1.numero++; /* incrémente de 1 la valeur du champ

numero de la structure art1*/

​

*

Programmer en langage C

120

Les types dérivés

Les structures

• Il possible d’affecter à une structure le contenu d’une structure définie à partir du même modèle. Par exemple nous pouvons écrire:
• art1=art2;
• Une telle affectation remplace :
• art1.numero = art2.numero;
• art1.qte = art2.qte;
• art1.prix = art2.prix;
• Initialisation d’une structure au moment de sa déclaration :
• Struct enreg art1={100,290,3000};

​

​

*

Programmer en langage C

121

Les types dérivés

Les structures

• Structure comportant des tableaux:
• Struct personne{ char nom[30];

char prenom[20];

float heures[31];

} employe, courant;

/*heures: nbre d’heures du travail dans chaque jours du mois*/

• employe.heures[4];/*5^ème éléments du tableau heures*/
• employe.nom[0];/* premier caractère du champ nom*/
• Initialisation:
• Struct personne ={‘’Dupont’’, ‘’julea’’, {8, 7, 8, 6, 8, 0,0, 8}}

*

Programmer en langage C

122

Les types dérivés

Les structures

• Tableaux de structures

struct point { char nom;

int x;

int y;

};

struct point courbe[50];

• Cette structure sert à représenter un point d’un plan qui serait défini par son nom(caractère) et ses deux coordonnées.
• courbe[i].nom; courbe[i].x; courbe[i].y; /*représente le nom du point de rang i, la valeur du champ x et la valeur du champ y*/
• Initialisation :
• Struct point courbe[50]={{‘A’,10,25},{‘M’,13,34},{‘R’,2,6}};

*

Programmer en langage C

123

Les types dérivés

Les structures

• Structures comportant d’autres structures:
• Supposant que l’intérieur de la structure employe et courant nous ayant besoin d’introduire deux dates: la date d’embauche et la date d’entrée. Si ces dates sont elles-mêmes des structures comportant trois champs correspondant au jour et à l’année, nous pouvons alors procéder aux déclarations suivantes :
• struct date { int jour;

int mois;

int annee;};

• Struct personne{ char nom[30];

char prenom[20];

float heures[31];

struct date date_embauche;

struct date date_poste;

} employe, courant;

*

Programmer en langage C

124

Les types dérivés

Les structures

• La notation :
• Employe.date_embauche.annee

Représente l’année d’embauche correspondant à la structure employe. Il s’agit d’une valeur de type int.

• Courant.date_embauche

Représente la date d’embauche de la structure courant, et nous pouvons faire l’affectation:

• Courant.date_embauche=employe.date_poste;

​

*

Programmer en langage C

125

Les types dérivés

Les structures

• Exercice:
• Ecrire un programme qui :
• lit au clavier des informations dans un tableau de structure du type point défini comme suit:

Struct point{

int num;

frloat x;

float y;

}

Le nombre d’éléments du tableau sera fixé par une instruction #define.

• Affiche à l’écran l’ensemble des informations précédentes.

​

*

Programmer en langage C

126

Les types dérivés

Les unions

• Il est parfois nécessaire de manipuler des variables auxquelles on désire affecter des valeurs de type différents. Supposons que l'on désire écrire un package mathématique qui manipulera des nombres qui seront implémentés par des int, tant que la précision des entiers de la machine sera suffisante et qui passera automatiquement à une représentation sous forme de flottants dès que ce ne sera plus le cas. Il sera nécessaire de disposer de variables pouvant prendre soit des valeurs entières, soit des valeurs flottantes. Ceci peut se réaliser en C, grâce au mécanisme des unions.

*

Programmer en langage C

127

Les types dérivés

Les unions

• Une définition d'union à la même syntaxe qu'une définition de structure, le mot clé struct étant simplement remplacé par le mot clé union.
• Exemple:

Union partage{

char c;

int i;

}

union nombre{

int i;

float f;

}

​

*

Programmer en langage C

128

Les types dérivés

Les unions

• on déclarera une variable p de type union partage par :
• union partage p;
• cette variable pourra posséder soit une valeur entière, soit un caractère, mais pas les deux à la fois.
• on déclarera une variable n de type union nombre par
• union nombre n;
• cette variable pourra posséder soit une valeur entière, soit une valeur flottante, mais pas les deux à la fois.

​

​

*

Programmer en langage C

129

Les types dérivés

Les pointeurs

• La mémoire de votre ordinateur
• Création d’un pointeur
• Définition
• Déclaration
• Initialisation
• Opérations élémentaires sur les pointeurs
• Pointeurs et tableaux
• Pointeurs et tableaux à deux dimensions
• Arithmétiques des pointeurs
• Allocation dynamique
• Allocation dynamique: Fonctions malloc et free

*

Programmer en langage C

130

La mémoire de votre ordinateur

• La compréhension des pointeurs, repose sur le fonctionnement du mémoires de votre ordinateur.
• Tout d’abord un bref rappel sur le fonctionnement des ordinateurs. Un ordinateur comporte un processeur et de la mémoire. Les deux sont connectés par un bus, c'est-à-dire un ensemble de lignes électriques

​

​

*

Programmer en langage C

131

Les pointeurs

1000

1004

1008

1009

1010

1014

1018

​

Bus

Processeur

Mémoire(RAM)

Adresses

Un octet = 8 bits

La mémoire de votre ordinateur

• La mémoire vive de votre ordinateur est constituée de milliers d’emplacements mémoire rangés de façon séquentielle. Chaque emplacement a une adresse unique, comprise entre 0 et une valeur maximale qui dépend de la quantité de mémoire installée sur votre ordinateurs.
• Lorsqu’une variable est déclarée, le compilateur réserve un emplacement mémoire (une série de bits qu’on ne lit/écrit pas un par un mais par paquets de huit, ce que l'on appelle un octet (byte).) avec une adresse unique pour stocker cette variable(qu’on peut relire plus tard) .
• Le compilateur associe l’adresse au nom de la variable. Quand le programme utilise le nom de la variable, il accède automatiquement à l’emplacement mémoire correspondant

​

*

Programmer en langage C

132

Les pointeurs

La création d’un pointeur

• Dans la figure précédente nous avons déclaré une variable rate et nous l’avons initialisé à 100. Le compilateur à réservé un emplacement mémoire à l’adresse 1004, qu’il associe au nom de la variable.
• L’adresse de cette variable rate est un nombre, ce qui nous permet de l’utiliser comme n’importe quel autre nombre en langage C.
• Si vous connaissez l’adresse d’une variable, vous pouvez créer une autre variable pour y stocker l’adresse de la première.
• La première étape consiste à déclarer la variable dans laquelle on stockera l’adresse de rate.

​

​

​

*

Programmer en langage C

133

Les pointeurs

La création d’un pointeur

• Soit p_rate la variable dans laquelle on stockera l’adresse de rate, d’après le schéma ci-dessous un emplacement mémoire a été réservé pour p_rate

​

​

​

• L’étape suivante consiste à stocker l’adresse de rate dans la variable p_rate, celle-ci représente maintenant l’emplacement mémoire de la variable rate

*

Programmer en langage C

134

Les pointeurs

1001 1002 1003 1004 1005

p_rate

rate

Définition

• Un pointeur est une variable qui contient l'adresse d'une autre variable.

​

*

Programmer en langage C

135

Les pointeurs

Déclaration

• On déclare un pointeur par l’instruction :

type *nom_du_pointeur ;

​

• Où: type est le type de la variable pointée,
• l’identificateur nom_du_pointeur est le nom de la variable pointeur et * est l’opérateur qui indiquera au compilateur que c’est un pointeur.

 Exemple : int *p; float *p_float; char *p_char;

On dira que :p est un pointeur sur une variable du type int , ou bien p peut contenir l'adresse d'une variable du type int

*p est de type int, c’est l’emplacement mémoire pointé par p.

​

​

Initialisation

• Déclarer un pointeur n’est pas suffisant, si vous ne le faites pas pointer sur une variable, il est inutile.
• Un pointeur doit contenir l’adresse d’une variable en utilisant l’opérateur &, quand il est placé avant le nom de la variable, l’opérateur d’adresse renvoie l’adresse de cette variable. Son initialisation est une instruction de la forme : pointeur=&variable;

​

*

Programmer en langage C

136

Les pointeurs

Initialisation

• Exemple 1 :
• int A, B, *P; /*supposons que ces variables occupent la mémoire à partir de l’adresse 1000 */
• A = 10;
• B = 50;
• P = &A ; // se lit : mettre dans P l’adresse de A
• B = *P ; /* se lit : mettre dans B le contenu de

la variable pointée par P */

• *P = 20; /*mettre la valeur 20 dans la variable

pointé par P*/

• P = &B; // P pointe sur B

​

*

Programmer en langage C

137

Les pointeurs

Exemple 1:

void main()

{ int v=12;

int u=10;

int *vP; /*pointeur sur int*/

vP = &v; /*affectation du pointeur */

u = *vP;

printf(“u=%d v=%d\n”,u,v);

*vP = 25;

printf(“u=%d v=%d\n”,u,v);

printf(“*vP=%d”,*vP);

}

*

Programmer en langage C

138

Les pointeurs

Exemple 2 :

#include <stdio.h>

#include <conio.h>

Void main( )

{ float a , *p; /*supposons que ces variables sont représentées en

mémoire à partir de l’adresse 1000*/ �clrscr( ); // pour effacer l’écran<conio.h>

p = &a;

printf(‘’Entrer une valeur : ‘’);

scanf(‘’%f’’ ,p); // on saisie la valeur 12.4 

printf(‘’\nAdresse de a = %d Contenu de a = %f’’ ,p,*p);

*p += 0.4;

printf(‘’a = %f *p = %f ‘’, a,*p);

getch( ); // pour lire un caractère <conio.h>}

*

Programmer en langage C

139

Les pointeurs

Opérations élémentaires sur les pointeurs

• L’opérateur & : ’adresse de’ : permet d’obtenir l’adresse d’une variable.
• L’opérateur * : ’contenu de’ : permet d’accéder au contenu d’une adresse.
• Si un pointeur P pointe sur une variable X, alors *P peut être utilisé partout où on peut écrire X.
• Exemple :
• int X=1, Y, *P Après l’instruction, P = &X ; On a :
• Y = X + 1 équivalente à Y = *P + 1
• X += 2 équivalente à *P += 2
• ++X équivalente à ++ *P
• X++ équivalente à (*P)++

*

Programmer en langage C

140

Les pointeurs

Opérations élémentaires sur les pointeurs

• Le seul entier qui puisse être affecté à un pointeur d’un type quelconque P est la constante entière 0 désignée par le symbole NULL défini dans <stddef.h>.
• On dit alors que le pointeur P ne pointe ’nulle part’.
• Exemple :

#include <stddef.h>

int *t, x , *r;

short y = 10 , *pt = &y;

t = NULL ; /* Correct */

t = 0 ; /* Correct */

x = 0 ;

t = x ; /* Incorrect ! bien que x vaille 0 */

r = &x ;

t = r ; /* Correct : p et q pointe sur des variables de même type*/

t = pt ; /* Incorrect : p et pt pointe sur des variable de type différent */

*

Programmer en langage C

141

Les pointeurs

Exercices

• Trouvez les erreurs dans les suites d’instruction suivantes :

​

a) int *p , x = 34; *p = x

b) int x = 17 , *p = x; *p = 17

c) double *q; int x = 17 , *p;

p = &x; q =p;

d) int x, *p; &x = p;

*

Programmer en langage C

142

Les pointeurs

1. *p = x est incorrect parce que le pointeur p n’est pas initialisé

​

b) p = x est incorrect. Pour que p pointe sur x :p = &x

​

c) q = p incorrect. q et p deux

pointeurs sur des types différent

​

d)&x = p incorrect. &x n’est pas

une variable (lvalue) et par conséquent ne peut pas figurer à gauche d’une affectation.

​

​

Pointeurs et tableaux

• En C, il existe une relation très étroite entre tableaux et pointeurs. Ainsi, chaque opération avec des indices de tableaux peut aussi être exprimée à l’aide de pointeurs. En effet, le nom d’un tableau représente l’adresse de son premier élément :
• Tableau à une dimension (int T[N]) :
• le nom T du tableau est un pointeur constant sur le premier élément (1^er entier) du tableau
• T et &T[0] contiennent l’adresse du premier élément (1er entier) du tableau.
• Tableau à deux dimensions( int T[N][M]) :
• le nom T est un pointeur constant sur le premier tableau d’entiers
• T[i] est un pointeur constant sur le premier élément (1er entier) du ième tableau.
• T et T[0] contiennent la même adresse mais leur manipulation n’est pas la même puisqu’ils ne représentent pas le même type de pointeur.

*

Programmer en langage C

143

Les pointeurs

Pointeurs et tableaux

• Adressage et accès aux composantes d’un tableau à une dimension
• En déclarant un tableau A de type int (int A[N]) et un pointeur P sur des variables entière (int *P), l’instruction P = A crée une liaison entre le pointeur P et le tableau A en mettent dans P l’adresse du premier élément de A (de même P = &A[0]).
• A partir du moment où P = A, la manipulation du tableau A peut se faire par le biais du pointeur P. En effet
• p pointe sur A[0] *p désigne A[0]
• p+1 pointe sur A[1] *(p+1) désigne A[1]
• ..
• p+(N-1) pointe sur A[N-1] *(p+N-1) désigne A[N-1]

​

*

Programmer en langage C

144

Les pointeurs

Exemple ( Lecture et Affichage d’un tableau matérialisé par un pointeur)

#include  ’’stdio.h’’

#define N 10

void main()

{ float t[N] , *pt ;

int i ;

printf("Entrez %d entiers\n", N) ;

pt = &t[0] ; /* ou pt = t */

for (i = 0 ; i<N; i++)

scanf("%f", pt+i) ; /* pt+i pointe sur t[i] */

printf("\n Tableau lu : \n") ;

for (i = 0 ; i<N ; i++)

printf("%7.2f", *(pt+i)) ; /* *(pt+i) équivalente à pt[i]*/

}

*

Programmer en langage C

145

Les pointeurs

Exemple ( Lecture et Affichage d’un tableau matérialisé par un pointeur)

/* Autre Solution sans déclarer la variable i */

#include <stdio.h>

#define N 10

void main()

{ float T[N] , *pt ;

printf("Entrez %d entiers\n", N) ;

for (pt = T ; pt<T+N; pt++)

scanf("%f", pt) ;

printf("\nTableau lu : \n") ;

for (pt = T ; pt<T+N; pt++)

printf("%7.2f", *pt) ;

}

*

Programmer en langage C

146

Les pointeurs

Pointeurs et tableaux à deux dimensions

• En déclarant une matrice A de type int (int A[M][N]) et un pointeur P sur des variables entières (int *P),
• l’instruction P = A[0] crée une liaison entre le pointeur P et la matrice A en mettent dans P l’adresse du premier élément de la première ligne de la matrice A ( P = &A[0][0]). A partir du moment où P = A[0], la manipulation de la matrice A peut se faire par le biais du pointeur P. En effet :

p pointe sur A[0][0] et * p désigne A[0][0]

p + 1 pointe sur A[0][1] et * ( p + 1 ) désigne A[0][1]

..

p + N pointe sur A[1][0] et * ( p + N ) désigne A[1][0]

p + N + 1 pointe sur A[1][1] et * ( p + N + 1 ) désigne A[1][1]

..

p + M * N-1 pointe sur A[M-1][N-1] et * ( p + M * N -1 ) désigne A[M-1][N-1]

*

Programmer en langage C

147

Les pointeurs

Exemple ( Lecture et Affichage d’une matrice matérialisé par un pointeur)

#include <stdio.h>

#define M 4

#define N 10

void main()

{ short A[M][N] ;

short *pt ;

int i, j ;

/* lecture d’une matrice */

pt = &A[0][0] ; /* ou bien pt = A[0] ; */

for (i = 0 ; i<M ; i++)

{

printf("\t ligne n° %d\n", i+1) ;

for (j = 0 ; j<N ; j++)

scanf("%i", pt + i * N + j ) ;

} for (i = 0 ; i<M ; i++)

{ for (j = 0 ; j<N ; j++)

printf("%d", *( pt + i * N + j ) ) ;

printf("\n") ; }}

*

Programmer en langage C

148

Les pointeurs

Arithmétiques des pointeurs

• Affectation par un pointeur sur le même type :
• Soient P1 et P2 deux pointeurs sur le même type de données.
• L’affectation : P1 = P2 ; fait pointer P1 sur le même objet que P2.
• Addition et soustraction d’un nombre entier :
• Si P pointe sur l’élément A[i] d’un tableau, alors :
• P+n pointe sur A[i+n] et P-n pointe sur A[i-n]

*

Programmer en langage C

149

Les pointeurs

Arithmétiques des pointeurs

• Incrémentation et décrémentation d’un pointeur :
• Si P pointe sur l’élément A[i] d’un tableau, alors après l’instruction :
• P++ ; P pointe sur A[i+1]
• P += n ; P pointe sur A[i+n]
• P-- ; P pointe sur A[i-1]
• P -= n ; P pointe sur A[i-n]
• Comparaison de deux pointeurs :
• On peut comparer deux pointeurs de même type par : <, >, <=, >=, == ou !=
• La comparaison de deux pointeurs qui pointent dans le même tableau est équivalente à la comparaison des indices correspondants.

*

Programmer en langage C

150

Les pointeurs

Autres déclarations des pointeurs :

• En C, il existe d’autres déclarations des pointeurs. En effet :
• Tableau de pointeurs :
• int *Tab[20] ;
• déclare un tableau Tab de 20 pointeurs d’entiers.
• Pointeur de tableaux :
• int (*pt)[30] ;
• déclare un pointeur pt sur des tableaux de 30 composantes.
• Pointeur de pointeurs :
• int **pt ;
• déclare un pointeur pt qui pointe sur des pointeurs d’entiers.

*

Programmer en langage C

151

Les pointeurs

Allocation dynamique

• La déclaration d’un tableau définit un tableau statique  (il possède un nombre figé d’emplacements). Il y a donc un gaspillage d’espace mémoire en réservant toujours l’espace maximal prévisible.
• Il serait souhaitable que l’allocation de la mémoire dépend du nombre d’éléments à saisir. Ce nombre ne sera connu qu’à l’exécution : c’est l’allocation dynamique.

*

Programmer en langage C

152

Les pointeurs

Allocation dynamique

• Fonction d’allocation dynamique de la mémoire
• Bibliothèque <stdlib.h>
• char *malloc(taille) ; //allocation d’un bloc
• char *calloc(taille, sizeof(type)) ;//allocation & initialisation d’un

//bloc

• char *realloc(char *, taille); //modification de la taille d’un bloc
• void free(char *) ; //libération d’un bloc
• Chacune des fonctions malloc, calloc ou realloc, prend une zone d’une taille donnée dans l’espace mémoire libre réservé pour le programme (appelé tas ou heap) et affecte l’adresse du début de la zone à une variable pointeur.
• S’il n’y a pas assez de mémoire libre à allouer, la fonction renvoie le pointeurNULL.

​

*

Programmer en langage C

153

Les pointeurs

Allocation dynamique: Fonctions malloc et free

• malloc
• <pointeur> = <type> malloc(<taille>);
• <type> est un type pointeur définissant la variable pointé par <pointeur>
• <taille> est la taille, en octets, de la zone mémoire à allouer dynamiquement, <taille> est du type unsigned int, donc on ne peut pas réserver plus de 65536 octets à la fois
• La fonction malloc retourne l’adresse du premier octet de la zone mémoire allouée. En cas d’échec, elle retourne NULL.

*

Programmer en langage C

154

Les pointeurs

Allocation dynamique: Fonctions malloc et free

• free
• Si on n’a plus besoin d’un bloc de mémoire réservé dynamiquement par malloc, alors on peut le libérer à l’aide de la fonction free.
• free(<pointeur>);
• Libère le bloc de mémoire désigné par le pointeur <pointeur>

​

*

Programmer en langage C

155

Les pointeurs

Exemple (Allocation dynamique, Saisie et Affichage d’un tableau )

#include <stdio.h>

#include <stdlib.h>

void main()

{short *pt;

int N , i;

printf("Entrez la taille N du tableau \n") ;

scanf("%d", &N) ;

pt = ( short * ) malloc( N * sizeof( short ) );

if (pt == NULL)

{printf("Mémoire non disponible") ;

system("pause");

}

*

Programmer en langage C

156

Les pointeurs

Exemple (Allocation dynamique, Saisie et Affichage d’un tableau )

​

printf("Saisie du tableau : ");

for ( i = 0 ; i < N; i++)

scanf("%d", pt + i ) ;

printf("Affichage du tableau ") ;

for ( i= 0 ; i < N; i++)

printf("%d\t", *( pt + i ) ) ;

free( pt );

}

*

Programmer en langage C

157

Les pointeurs

Annexe A:

• Explication de l’exemple 1

*

Programmer en langage C

158

Les pointeurs

Annexe A:

• Gestion dynamique des tableaux
• EXEMPLE :

/* Déclaration d'un pointeur sur des entiers p et de la taille du tableau N */

int* p=NULL;

int N;

/* Saisie de la taille du tableau par l'utilisateur */

scanf ("%d",&N);

/* Allocation dynamique de la zone mémoire occupée par le tableau */

p = (int*)malloc (N*sizeof(int));

​

*

Programmer en langage C

159

Les pointeurs

Pointeurs et structures

• Les pointeurs membres d’une structure
• Un pointeur qui est membre d’une structure se déclare de la même façon qu’un pointeur qui ne l’est pas, en utilisant l’opérateur indirect(*), exemple:

Struct data {

int *valeur;

int *taux;

} premier;

• Soit cout et interet de variable de type int tel que :
• int cout, interet;
• L’initialisation du pointeur valeur et taux suit la syntaxe suivante :
• premier.valeur=&cout;// (*premier.valeur=cout;)
• premier.taux=&interet; // (*premier.taux=interet;)

*

Programmer en langage C

160

Les pointeurs

Pointeurs et structures

• Les pointeurs vers une structure
• Soit la structure personne définie par:

Struct point{

int num;

float x;

float y;

}

• On déclarera une variable de type pointeur vers cette structure de la façon suivante :
• struct point *p;
• Pour initialiser ce pointeur, il faut déclarer une structure sur le modèle struct point, sur laquelle il va pointer :
• Struct point pnt;
• p=&pnt;

​

​

*

Programmer en langage C

161

Les pointeurs

Pointeurs et structures

• Les pointeurs vers une structure
• Pour accéder aux membres de la structure point, on utilise soit l’opérateur (.) :
• (*p).num=1;
• (*p).x=1.2;
• (*p).y=2.5;
• soit (->) comme suit:
• p ->num=1;
• p ->x=1.2;
• p ->y=2.5;

​

​

​

​

​

​

​

*

Programmer en langage C

162

Les pointeurs

Pointeurs et structures

• Pointeurs et tableaux de structures
• Soit la structure définie par:
• struct part{

int nombre;

char nom[10];

};

Nous pouvons déclarer un tableau appartenant au type part

• struct part data[50];

Nous pouvons ensuite déclarer un pointeur vers une structure de

type part, et l’initialiser pour pointer sur la première structure du

tableau data:

• struct part *p_part;
• p_part=&data[0];// ou bien écrire p_part=data;

Nous obtenons un tableau de structures de type part et un pointeur

vers le premier élément du tableau. On affiche le contenu du premier

élément avec l’instruction:

• printf(’’ %d %s ’’, p_part->nombre , p_part ->nom);

​

​

*

Programmer en langage C

163

Les pointeurs

Pointeurs et structures

• Pointeurs et tableaux de structures :exemple

#include<stdio.h>

#define max 4

Struct part{

int nombre;

char nom[10];

}data[Max]={1,’’smith’’,

2, ‘’jones’’,

3, ‘’Adams’’,

4,’’Wilson’’

};

Struct part *p_part;

int count;

void main(){

P_part=data;

For(count=0;count<Max;count++)

{ printf(‘’A l’adresse %d : %d %s\n’’,p_part,p_part->nombre,p_part->nom);

p_part++;}}

​

​

*

Programmer en langage C

164

Les pointeurs

Les Fonctions

​

​

​

​

• Définition
• Exemple de définition et d’utilisation d’une fonction en C
• Exemple de fonction sans résultat
• Le cas des fonctions sans paramètres
• Règles
• Une fonction peut en appeler une autre
• En langage C, les paramètres sont transmis par valeur
• Passage des paramètres par adresse
• Passage de tableau en paramètre
• Passage de structure en paramètre
• Fonctions récursives
• Fonctions prédéfinies : math.h

*

Programmer en langage C

165

Définition

• Une fonction est un bloc de code C indépendant, référencé par un nom, qui réalise une tâche précise et qui peut renvoyer une valeur au programme qui l’a appelée :
• Une fonction est référencée par un nom: ce nom est unique et en l’introduisant dans la source de votre programme, vous pouvez exécuter le code de la fonction. une fonction peut être appelée par une autre fonction.
• Une fonction est indépendante : une fonction peut effectuer avec ou sans échanges avec une autre partie du programme.
• Une fonction réalise une tâche particulière : cela peut être l’envoi d’une ligne de texte vers l’imprimante, un tri, ou le calcul d’une racine carrée.
• Une fonction peut renvoyer une valeur au programme appelant: Quand ce programme appelle la fonction, le code de cette fonction est exécuté. Ces instructions peuvent renvoyer une information au programme.

​

​

*

Programmer en langage C

166

Les fonctions

Définition : Syntaxe

type identificateur ( liste de-déclarations-de-paramètres )

{

liste-de-déclarations_option(optionnel)

liste-d'instructions

}

​

• type identificateur ( liste-de-déclarations-de-paramètres );

🖝porte le nom de prototype de fonction.

​

*

Programmer en langage C

167

Les fonctions

Définition : Sémantique

• Type :est le type de la valeur rendue par la fonction ;
• identificateur :est le nom de la fonction ;
• Liste de déclarations-de-paramètres : est la liste (séparés par des virgules) des déclarations des paramètres formels.
• La liste-de-déclarations_option : permet si besoin, de déclarer des variables qui seront locales à la fonction, elles seront donc inaccessibles de l'extérieur.
• La liste-d'instructions: est l'ensemble des instructions qui seront exécutées sur appel de la fonction. Parmi ces instructions, il doit y avoir au moins une instruction du type : return expression ;

*

Programmer en langage C

168

Les fonctions

Définition: Appel d’une fonction

• Syntaxe :
• Expression :

🡺 identificateur ( liste-d'expressions )

• Sémantique :
• Les expressions de liste-d'expressions sont évaluées, puis passées en tant que paramètres effectifs à la fonction de nom identificateur, qui est ensuite exécutée. La valeur rendue par la fonction est la valeur de l'expression appel de fonction.

​

*

Programmer en langage C

169

Les fonctions