Langage C

1
 Table de matières

1-Introduction
2-Notions de base

3-Types de base, Opérations et expression

4- Lire et Ecrire des données
5-Structures de contrôle
6-Tableaux
7-Fonctions
8-Chaines de caractères

2
1-Introduction

3
 1-Introduction

Langage informatique

 On appelle « langage informatique » un langage destiné à

décrire l'ensemble des actions consécutives qu'un ordinateur
doit exécuter.

Un langage informatique est ainsi une façon pratique pour

nous (humains) de donner des instructions à un ordinateur.

4
 1-Introduction

1.1 Histoire de langage c

 En 1972, dans les ‘Bell Laboratories’, Ritchie a conçu le

langage C pour développer une version portable du système
d’exploitation UNIX.

 En 1978, le duo Kernighan/ Ritchie a publié la définition

classique du langage C,

 En 1983, le ‘American National Standards Institute’ (ANSI)

chargeait une commission de mettre au point ‘une définition
explicite et indépendante de la machine pour le langage C’. Le
résultat était le standard Ansi-C.

5
 1-Introduction

1.2. Caractéristiques du langage C

C est un langage :
 Universel : permet aussi bien la programmation système que la programmation
de divers applications (scientifique, de gestion,…)

 De haut niveau : C est un langage structuré (offre plusieurs structures de

contrôle) et typé (déclarations obligatoires)

 Prés de la machine : offre des opérateurs qui sont très proches de ceux du
langage machine…

 Portable : en respectant le standard ANSI-C, il est possible d’utiliser le même

programme sur d’autres compilateurs.

Très rapide: Aucun contrôle de débordement n'est effectué, ce qui apporte une
plus grande vitesse.
6
2-Notions de base

7
 2-Notions de base

2.1. Premier programme en langage C

#include <stdio.h>
void main( )
{
printf("Bonjour tout le monde \n");
}

Ce programme affiche le message :"Bonjour tout le

monde".

8
 2-Notions de base

2.2. Structure d'un programme C

Tout programme est toujours constitué de trois phases :

Lecture des
données

Traitement des données

Affichage des
résultats

Remarque:
On parle parfois pour un programme donné d'application ou de
logiciel.
9
 2-Notions de base

2.2. Structure d'un programme C

Structure d'un programme:
 2-Notions de base

2.2. Structure d'un programme C

Importation des bibliothèques

Selon ce que l'on souhaite faire dans notre programme, on peut

avoir besoin de différentes fonctions.
Celles-ci sont disponibles dans des bibliothèques. Par exemple :

#include<stdio . h> propose des fonctions de saisie et d'affichage

#include<conio . h> propose d'autre fonctions d'entrées-sorties

11
 2-Notions de base

2.3. Structure d'un programme C

Corps du programme ‘La fonction main’

 Une fonction et une seule s'appelle main.

 C'est la fonction principale des programmes en C ; elle se trouve

obligatoirement dans tous les programmes.

 L'exécution d'un programme entraîne automatiquement

l'appel de la fonction main.

12
 2-Notions de base

2.3. Structure d'un programme C

Corps du programme ‘La fonction main’
 On place dans les accolades du main les instructions que l'on
souhaite voir s'exécuter :

int main( ) void main( )

{ {
<instructions à exécuter>; <instructions à exécuter>;
return 0 ; }
}

Remarque:
Chaque ligne se termine par un point-virgule.
13
 2-Notions de base
2.3. Structure d'un programme C
Commentaire

 Sont utilisés pour rendre un programme plus compréhensible.

 Sont ignorés par le compilateur
 Un commentaire sur une ligne commence par les caractères //.
 Un commentaires multi ligne commence par les caractères /* et
se termine par*/.
 Attention: on ne peut donc pas imbriquer des commentaires.

14
 2-Notions de base
2.3. Structure d'un programme C

Commentaire
/***********************************/
/* ce programme vous affiche Bonjour */
/***********************************/
/*fichier d’entête pour utiliser la fonction printf*/

#include <stdio.h>
int main() /* la fonction principale main */
{
printf(‘‘Bonjour’’); // afficher Bonjour
Return 0;
}

15
3. Types de base, Opérateurs et expression

16
3. Types de base, opérateurs et expression
3.1. Constantes

Définition d'une constante

 Elle ne change jamais de valeur pendant l'exécution d'un

programme. Elle est généralement stockée dans la mémoire morte
d'une machine.

 Il n'y a pas d'allocation mémoire, mais on peut affecter à un

identificateur (Nom) une valeur constante par l'instruction #define.

17
3. Types de base, opérateurs et expression
3.1. Constantes
Définition d'une constante

Syntaxe:
#define <identificateur> <valeur>

Exemple

18
3. Types de base, opérateurs et expression
3.2. Variables

 Les variables contiennent les valeurs utilisées pendant l'exécution

du programme.
 Déclarer une variable, c'est prévenir le compilateur qu'un nom va
être utilisé pour designer un emplacement de la mémoire.
 Les noms des variables sont des identificateurs quelconques

 Toute variable doit être déclarée avant les instructions et son

type spécifié dès la déclaration.

19
3. Types de base, opérateurs et expression
3.2. Variables

Syntaxe:
<type> <identificateur 1>,..,<identificateur n> ;

Exemple

20
3. Types de base, opérateurs et expression
3.2. Variables
Le type
Détermine la taille de la variable et les opérations pouvant être effectuées
L'identificateur
 C'est le nom affecté à la variable, le nombre de caractères peut être limité,
cela dépend du compilateur utilisé.
 L’identificateur d’une variable doit toujours être écrit de la même façon :
Mon_Identificateur ≠ mon_identificateur ≠ MON_IDENTIFICATEUR.
Les seuls caractères autorisés pour les noms (identificateur) de variables
sont :
 lettres NON accentuées ;
 chiffres (sauf au début du nom) ;
 caractères souligné « _ ».

21
3. Types de base, opérateurs et expression
3.2. Variables
En TURBO C

22
3. Types de base, opérateurs et expression
3.2. Variables

Bus de commandes Adresses

mémoire
1 0 0 0 1 1 0 0 0 1 1 1 0 0 1 0 0
0 1 1 1 0 0 1 1 1 0 0 0 1 1 0 1 1
1 0 0 0 1 1 0 0 0 1 1 1 0 0 1 0 2
0 1 1 1 0 0 1 1 1 0 0 1 0 1 0 1 3
1 0 0 0 1 1 0 0 0 1 1 1 0 0 1 0 4
Mot mémoire 1 0 0 0 1 0 0 1 0 1 0 1 0 1 1 0 5
d’adresse 3 1 0 0 0 1 1 0 0 0 1 1 1 0 0 1 0 6
0 1 1 1 0 1 1 0 1 0 1 0 1 1 0 1 7

Mémoire de capacité de 8 mots de 16 bits.

1 octet = 8 bits.
Mémoire de capacité de 128 bits (16 octets).

Figure 2 : La mémoire centrale

23
3. Types de base, opérateurs et expression
3.2. Variables
Exemple
float rayon; /*Déclaration de réel*/
int i,j; /*Déclaration d’entier*/
char t; /*Déclaration de caractère*/
Double pi; /*Déclaration de réel double*/

Void main()
{
i=2;
j=3;
t=‘A’;
pi=3.14159;
}

24
3. Types de base, opérateurs et expression
3.2. Variables
Initialisation des variables

Deux solutions sont possibles:

25
3. Types de base, opérateurs et expression
3.3. Opérateurs standards
 Les opérateurs régissent toutes les opérations ou transformations sur les valeurs de
variables.
L'opérateur d'affectation
 C'est l'opérateur le plus utilisé. Il permet de modifier la valeur d'une variable.
L’affectation est toujours effectuée de la droite vers la gauche
Le programme commence par évaluer la valeur de l'expression puis l'affecte avec le
signe = à la variable par son identificateur.

Syntaxe:
<identificateur> = <expression> ;

Exemple
int main ( )
{
int V ;
V = 5;
return 0 ;
} 26
3. Types de base, opérateurs et expression
3.3. Opérateurs standards
Les opérateurs arithmétiques.

Les opérateurs d'incrémentation et de décrémentation.

Si l'opérateur d'incrémentation ou de décrémentation est placé avant l'identificateur

alors la variable sera incrémentée ou décrémentée avant d'être utilisée.

27
3. Types de base, opérateurs et expression
3.3. Opérateurs standards
Les opérateurs relationnels
Sont utilisés pour les structures conditionnelles, de choix et itératives,.
Ils permettent de comparer une variable par rapport à une autre variable ou une
valeur ou une expression.
Le résultat ne peut être que VRAI ou FAUX, on parle de valeur booléenne.

•FAUX correspond à 0.
•VRAI correspond à toute valeur différente de 0.

28
3. Types de base, opérateurs et expression
3.3. Opérateurs standards
Les opérateurs logiques.

Sont utilisés pour les structures conditionnelles, de choix et itératives,.

29
3. Types de base, opérateurs et expression
3.3. Opérateurs standards
L'opérateur de conversion de type.

Il existe deux conversions possibles:

La conversion implicite:

Elle est effectuée pour évaluer le même type de données lors d'évaluation
d'expressions. Les conversions systématiques de char en int, en float, en
double, la conversion se fait toujours du type le plus petit vers le plus long
(exemple: de char vers double).

La conversion explicite:

On peut changer le type d'une variable vers un autre type en utilisant
l'opérateur cast (type) en le mettant devant l'identificateur de variable à
convertir.

30
3. Types de base, opérateurs et expression
3.3. Opérateurs standards
La priorité des opérateurs.

31
4. Lire & Ecrire des données

32
 4. Lire & Ecrire des données
4.1. Ecriture formatée de données : printf()

 La fonction d’affichage printf() permet d'afficher des messages et/ou des valeurs de
variables sous différents formats.

Syntaxe:
printf (<"Format">,identificateur1, ....,identificateur n);

Le format
indique comment vont être affiché les valeurs des variables. Il est composé de texte et
de codes d'affichage suivant le type de variable.
Exemple
Code d’affichage identificateur

Printf ( "la valeur de la variable v est %d" , v ) ;

format

33
 4. Lire & Ecrire des données
4.1. Ecriture formatée de données : printf()
Codes d'affichage:

Important
Au début d'un programme utilisant les fonctions d'affichage et de saisie il est nécessaire d'écrire
#include <stdio.h>, car toutes les fonctions sont déclarées dans ce fichier d'en-tête.
34
 4. Lire & Ecrire des données
4.1. Ecriture formatée de données : printf()
Exemple:

#include <stdio.h>
void main( )
{
int a,b,c;
a=1;
b=2;
c=3;
printf (" La valeur de a est %d , celle de b est %d , et celle de c est %d" , a , b , c );
}

Le programme affiche:

La valeur de a est 1, celle de b est 2, et celle de c est 3.

35
 4. Lire & Ecrire des données
4.1. Ecriture formatée de données : printf()
On peut aussi mettre des codes de contrôles:

Exemple
#include <stdio.h>
void main()
{
printf("Salut je suis:\n\t étudiant à la faculté des sciences de Tétouan \n\t\t A bientôt");
}

36
 4. Lire & Ecrire des données
4.1. Ecriture formatée de données : printf()

Le programme affiche :

Salut je suis
étudiant à la faculté des sciences de Tétouan
A bientôt

37
 4. Lire & Ecrire des données
4.2. Lecture formatée de données : scanf()

 La fonction scanf() permet de saisir des valeurs de variables formatées à partir du

clavier.

Comme printf elle est composée d'un format et des identificateurs de variables à
saisir.

A la différence de printf, le format ne peut contenir de texte, il est juste composé du

format des valeurs à saisir.

Syntaxe:
scanf(<"Format">,&identificateur1, ...., &identificateurn);

38
 4. Lire & Ecrire des données
4.2. Lecture formatée de données : scanf()

Remarque
Le symbole & est obligatoire devant les identificateurs car scanf attend des
adresses et non des valeurs, sauf devant un identificateur de chaîne de caractères.

Les codes d'affichage pour printf deviennent les codes d'entrée pour scanf.

Pour l'utilisation de scanf il faut inclure le fichier stdio.h au début du programme.

39
 4. Lire & Ecrire des données
4.2. Lecture formatée de données : scanf()
Exemple:
Saisie de plusieurs variables.

#include <stdio.h>
Float a, b,c, det; /*déclaration des variables réelles*/
void main( )
{
printf ("Donne les valeurs de a,b et c ?"); /* Affichage de "Donne les valeurs de
a,b et c ?" */
scanf("%f %f %f",&a,&b,&c); /* Saisie de a,b,c */
det=(b*b)-(4*a*c); /* Calcul du déterminant */
printf("\n\n"); /* Deux sauts de ligne */
printf("Le déterminant = %f",det); /* Affichage du déterminant */
}

40
 4. Lire & Ecrire des données
4.3. Ecriture d’un caractère : putchar()

 La fonction putchar permet d'afficher un caractère à l'écran.

Syntaxe:
putchar(identificateur1);

41
 4. Lire & Ecrire des données
4.3. Ecriture d’un caractère : putchar()
#include <stdio.h>
char car1,car2,car3;
void main( )
{
car1=‘S';
car2= ‘M';
car3= ‘A';
putchar(car1); /* Affichage du caractère 1 -> donne un S */
putchar(car2); /* Affichage du caractère 2 -> donne un M */
putchar(‘I'); /* Affichage du caractère P */
putchar('\n'); /* Retour de ligne */
putchar(car1); /* Affichage du caractère 1 -> donne un S */
putchar(car2); /* Affichage du caractère 2 -> donne un M */
putchar(‘car3'); /* Affichage du caractère P */
}

Le programme affiche: SMI

SMA 42
 4. Lire & Ecrire des données
4.4. Lecture d’un caractère : getchar()
 La fonction getchar permet de saisir un caractère au clavier.

Syntaxe:
identificateur1 = getchar( void );

#include <stdio.h>
char car1;
void main( )
{

printf("Tapez un caractère ?"); /* Affichage de "Tapez un caractère ?" */

car1=getchar(); /* Saisie d'un caractère */
putchar('\n'); /* Changement de ligne */
printf("Le caractère saisi = %c",car1); /* Affichage du caractère saisi */
}

43
 5. Traitements conditionnels

Elles permettent en fonction d'une condition, de choisir de faire une

instruction ou un bloc d'instructions plutôt qu'un autre.

5.3 La structure <SI ... ALORS ...>.

C'est la structure de base.

44
 5. Traitements conditionnels
Exemple

ou

45
 5. Traitements conditionnels

5.2 La structure <SI ... ALORS ... SINON>.

Si la condition est vraie alors elle exécute l'instruction ou le bloc

d'instructions qui suit le if (si),
par contre si la condition est fausse alors elle exécute l'instruction ou le bloc
d'instructions qui suit else (sinon).

46
 5. Traitements conditionnels
Exemple

ou

47
 5. Traitements conditionnels

5.3 La structure de choix

Elle permet en fonction de différentes valeurs d'une variable de faire plusieurs
actions, si aucune valeur n'est trouvée alors ce sont les instructions qui suivent
default qui sont exécutées

48
 5. Traitements conditionnels
5.3 La structure de choix
Exemple

49
 5. Traitements conditionnels
5.3 La structure de choix
ou

50
 5. Traitements conditionnels
N'oubliez surtout pas les break ! Si par exemple, nous voulons afficher le nom d'un mois
en fonction de son numéro, on ecrit:

#include<stdio.h>
int numeroMois ;
void main()
{ prinf ("entrez le numero de mois");
scanf("%d",&numeroMois) ;

switch ( numeroMois )
{
case 1 : printf ( "janvier ") ; break ;
case 2 : printf ("fevrier") ; break ;
case 3 : printf ("mars") ; break ;
case 4 : printf ("avril") ; break ;
case 5 : printf ("mai") ; break ;
case 6 : printf (" juin ") ; break ;
case 7 : printf ("juillet") ; break ;
case 8 : printf ("aout") ; break ;
case 9 : printf ("septembre") ; break ;
case 10 : printf ("octobre") ; break ;
case 11 : printf ("novembre") ; break ;
case 12 : printf ("decembre") ; break ;
default : printf ("Je connais pas ce mois . . . ") ;
}
}
51
 6. Les structures itératives ou boucles
6.1. Définitions et terminologie
Une structure itérative ou boucle permet d'exécuter plusieurs fois de suite une même
séquence d'instructions. Cette ensemble d'instructions s'appelle le corps de la boucle.
Chaque exécution du corps d'une boucle s'appelle une itération.

Lorsque l'on s'appête à exécuter la première itération, on dit que l'on rentre dans la
boucle, lorsque la dernière itération est terminée, on dit qu'on sort de la boucle. Il existe
trois types de boucle :

While

do ... while

for

52
 6. Les structures itératives ou boucles
6.2. La structure <tant que> while
Dans cette structure la condition est testée au début .

53
 6. Les structures itératives ou boucles
Exemple

#include<stdio.h>
int i ;
void main()
{
/* boucle while<tant que faire> */
i=0;
while ( i<10 )
{
printf ("i = %d\n ",i) ;
i++ ;
}
}

54
 6. Les structures itératives ou boucles
6.3. La structure <FAIRE ... TANT QUE > do ... while.
Dans cette structure la condition est testée à la fin.

55
 6. Les structures itératives ou boucles
Exemple
#include <stdio.h>
int i;
void main()
{
i=0;
/* Boucle while <faire tant que> */
do
{
printf("i= %d\n",i);
i++;
}
while(i<10);
}

56
 6. Les structures itératives ou boucles
6.4. La structure <POUR ... FAIRE ... JUSQU’A ...> for
Dans cette structure la condition est testée au début. Elle est très intéressante car elle
est composée de trois parties:

L'instruction ou plusieurs instructions d'Initialisation qui sont exécutées une seule fois
au début de la structure.

L'instruction ou le bloc d'instructions du corps de la structure qui est exécuté à chaque

itération.

L'instruction ou plusieurs instructions qui sont exécutées à la fin de chaque itération

57
 6. Les structures itératives ou boucles
6.4. La structure <POUR ... FAIRE ... JUSQU’A ...> for

58
 6. Les structures itératives ou boucles
6.4. La structure <POUR ... FAIRE ... JUSQU’A ...> for

Exemple

#include <stdio.h>
int i;
void main()
{
for(i=0;i<10;i++)

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

59
Chapitre 7: Les tableaux

60
 7. Les tableaux
7.1. Introduction

Les variables, telles que nous les avons vues, ne permettent de stocker qu’une seule
données à la fois.

Pour mémoriser et manipuler de nombreuses données (100,1000,…), des variables

distinctes seraient beaucoup trop lourdes à gérer.

Pour résoudre ce problème, le langage C (ainsi que les autres langages de

programmations) propose une structure de données permettant de stocker l’ensemble de
ces données dans une « variable commune » appelée:

Tableau
61
 7. Les tableaux
7.2. Définition
On appelle tableau une variable composée de données de même type, stockée de
manière contigue en mémoire (les uns à la suite des autres).

Un tableau est une suite des élemente de même taille. Par conséquent, la taille (en octet)
du tableau est:
taille (en octet) du type de donnée*le nombre d’élément

Le type des éléments du tableau peut être:

Simple:char, int, float, double,…

Tableau à une dimension ou tableau unidimensionnel

tableau

Tableau à plusieurs dimensions ou tableau multidimensionnel

Autres: Pointeurs et structures
62
 7. Les tableaux
Tableaux à une dimension
Déclaration
La déclaration d’un tableau à une dimension se fait de la façon suivante:

<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 que l’on décide de donner au tableau, le nom du tableau suit
les mêmes règles qu’un nom de variale
Nombre_Elements: est une expression constante entière positive

Exemples:
Char caractere[12]; //Taille en octet: 1 octet*12=12 octets
int entier[10]; //Taille en octet: 2 octets*10=20 octets

Float reel_SP[8]; //Taille en octet: 4 octets*8=32 octets

63
 7. Les tableaux
Tableaux à une dimension
Initialisation à la déclaration
Il est possible d’initialiser le tableau à la définition:

<Type> Tableau[Nombre_Elements]={C1,C2,…,Cn};
ou C1,C2,…,Cn sont des constantes dont le nombre ne doit pas dépasser le
Nombre_Elements.

Si la liste de constantes ne contient pas assez de valeurs pour tous les éléments, les
éléments restantes sont initialisées à zero
Exemples:
Char voyelles[6] = {‘a’, ‘e’,’i’, ‘o’, ‘u’, ‘y’};
Int Tableau_entier1[10]= {10,5,9,-2};

float Tableau_reel8]= {1.5, 1.5e3,,5,9,-2};

shirt A[3]= {12,23,34,45,56}; //erreur!

64
 7. Les tableaux
Tableaux à une dimension
Exemple

Ou encore

65
 7. Les tableaux
Tableaux à une dimension (Vecteurs)
Accès aux composantes d’un tableau

Pour accéder à un élément du tableau, il suffit de donner le nom du tableau, suvi de

l’indice de l’élément entre crochets:
Nom_tableau[indice]

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
66
 7. Les tableaux
Tableaux à une dimension (Vecteurs)
Remarques

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 le clavier

L’écriture: printf("TAB[%d] =%d",i,TAB[i]); //Le contenu de TAB[i] sera

//affiché sur écran

67
 7. Les tableaux
Tableaux à une dimension (Vecteurs)
Remarques

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

=TAB[i]2

Pour initialiser un (TAB1) par les éléments d’un autre tableau (TAB2):

Éviter d’écrire TAB1=TAB2 (incorrect)

On peut par exemple écrire:

for(i=0;i<taille_tableau;i++)
TAB1[i]=TAB2[i];

68
 7. Les tableaux
Tableaux à une dimension (Vecteurs)

t Déclaration et représentation mémoire d’un tableau

La déclaration d’une variable au sein d’un programme provoque la réservation

automatique, par le compilateur, d’un espace de la mémoire. Ce qui permettra,par
conséquent, de conserver les valeurs assignées à cette variabble le long de l’éxecution du
programme

La mémoire (RAM) est une superposition de cases mémoires ou rangées.

Chaque case mémoire est identifié par un numéro appelé adresse.

69
 7. Les tableaux
Tableaux à une dimension (Vecteurs)
t Exemples

1. Saisir et afficher des données d’un tableau d’entiers de 20 éléments aux maximum.

2. Rechercher une valeur dans un tableau: Etant donné un tableau et une valeur. rechercer
cette valeur dans le tableau. S’il existe, afficher sa position sinon afficher un message
d’erreur.

3. Déterminer la plus petite valeur du tableau d’entiers A. Afficher ensuite la valeur et la

position du minimum. Si le tableau contient plusieurs minimum, retenir la position du
premier minimum rencontré.

70
 7. Les tableaux
Tableaux à une dimension (Vecteurs)
t Déclaration et représentation mémoire d’un tableau
En C, la déclaration d’un tableau T induit une réservation automatique d’une zone mémoire
contigue( les cases mémoires sont successives)

Représentation mémoire:

71
 7. Les tableaux
Tableaux à plusieurs dimensions
Déclaration
De manière similaire, on peut déclarer un tableau à plusieurs dimensions;
<Type Simple> Nom_du_Tableau [Nbre_El_1]…[Nbre_E_N];
Chaque élément entre crochets désigne le nombre d’éléments dans chaque dimension;

Le nombre de dimension n’est pas limité.

Tableaux à deux dimensions (matrices)

Déclaration
<Type Simple> Nom_du_Tableau [Nbre_ligne]…[Nbre_colonne];

72
 7. Les tableaux

Tableaux à deux dimensions (matrices)

Exemple

int T[3][4];

On peut représenter un tel tableau de la manière suivante:

T[0][0] T[0][1] T[0][2] T[0][3]

T[1][0] T[1][1] T[1][2] T[1][3]

T[2][0] T[2][1] T[2][2] T[2][3]

73
 7. Les tableaux
Tableaux à deux dimensions (matrices)
Initialisation à la déclaration et accès aux éléments:
Les valeurs sont affectées ligne par ligne lors de l’initialisation à la déclaration
Accés aux composantes se fait par: Nom_tableau[ligne][colonne].

Exemples
float A[3][2] = { {-1.05 , 61.10} , {86e-5 , 87} , {-12.5} };

int B[4][4]={ {-1,10, 13, 16} , {+8,-077} , {} , {11,-14,30} }

-1.05 61.10 -1 10 13 16

A 86e-5 87 +8 -77 0 0
B
-12.5 0 0 0 0 0

11 -14 30 0
74
 7. Les tableaux
Tableaux à deux dimensions (matrices)

Déclarations et représentation en mémoire d’un tableau à 2 dimensions:

La déclaration d’un tableau T à deux dimensions (matrice) induit la réservation de l’espace

mémoire nécessaire pour acceuillir tous les éléments du tableau.

Les éléments de la matrice sont répartis en mémoire ligne par ligne.

75
 7. Les tableaux
Exemple: Soit T un tableau défini par: char T[3][4]
Répartition des éléments
de T en mémoire

T[0][0]
T[0][1]
T[0][2]
T[0][3]
T[1][0]
T[1][1]
T[1][2]
T[1][3]
T[2][0]
T[2][1]
T[2][2]
T[2][3] 76
 7. Les tableaux
Tableaux à deux dimensions (Vecteurs)
Exemples

1. Ecrire un programme qui lit les dimensions M et N d'un tableau T à deux dimensions du
type int (dimensions maximales: 50 lignes et 50 colonnes). Remplir le tableau par des
valeurs entrées au clavier et afficher le tableau ainsi que la somme de tous ses éléments

2. Ecrire un programme qui ui réalise l'addition de deux matrices A et B de mêmes

dimensions N et M, le résultat de l'addition sera mémorisé dans une troisième matrice C qui
sera ensuite affichée.

77
Chapitre 8 : CHAINES DE CARACTERES

78
 8. CHAINES DE CARACTERES

Déclaration de chaînes de caractères en C

char <NomVariable> [<Longueur>];

Exemples
char NOM [20];
char PRENOM [20];
char PHRASE [300];

79
 8. CHAINES DE CARACTERES

Mémorisation
Le nom d'une chaîne est le représentant de l'adresse du
premier caractère de la chaîne. Pour mémoriser une
variable qui doit être capable de contenir un texte de N
caractères, nous avons besoin de N+1 octets en mémoire

Exemple: Mémorisation d'un tableau

char TXT[10] = "BONJOUR !";

‘B’ ‘O’ ‘N’ ‘J’ ‘O’ ‘U’ ‘R’ ‘ ‘ ‘!’ ‘\0’

TXT

80
 8. CHAINES DE CARACTERES

Lecture d’une chaîne de caractère par scanf:

scanf avec le spécificateur %s lit un mot à partir du clavier
et le mémorise àl'adresse qui est associée à %s.

Exemple
char LIEU[25];
int JOUR, MOIS, ANNEE;
printf("Entrez lieu et date de naissance : \n");
scanf("%s %d %d %d", LIEU, &JOUR, &MOIS, &ANNEE);

81
 8. CHAINES DE CARACTERES

Fonction spécifique pour la lecture d’une chaîne de caractère: gets

 Syntaxe: gets( Chaine)

 gets lit une ligne de de caractères du clavier et la copie à
l'adresse indiquée par la variable Chaine. Le retour à la
ligne final est remplacé par le symbole de fin de chaîne '\0'.

Exemple
char LIEU[25];
printf("Entrez lieu de naissance : \n");
gets(LIEU);

82
 8. CHAINES DE CARACTERES

Affichage d’une chaîne de caractère par printf:

 printf avec le spécificateur de format %s permet d’afficher

une chaîne den caractères à l’écran.

Exemple
char LIEU[25];
int JOUR, MOIS, ANNEE;
printf("Entrez lieu et date de naissance : \n");
scanf("%s %d %d %d", LIEU, &JOUR, &MOIS, &ANNEE);
printf ("%s %d %d %d", LIEU, JOUR, MOIS, ANNEE);

83
 8. CHAINES DE CARACTERES

Fonction spécifique pour l’affichage d’une chaîne de caractère: puts

 Syntaxe: puts( Chaine)

 puts écrit la chaîne de caractères désignée par la variable
Chaine sur l’écran et provoque un retour à la ligne.

Exemple
char TEXTE[] = "Voici une première ligne.";
puts(TEXTE);
puts("Voici une deuxième ligne.");

84
 8. CHAINES DE CARACTERES

Ordre alphabétique (lexicographique) des chaînes de caractères:

 La précédence des caractères dans l'alphabet d'une

machine est dépendante du code du caractère utilisé. Pour
le code ASCII, nous pouvons constater l'ordre suivant:
. . . ,0,1,2, ... ,9, . . . ,A,B,C, ... ,Z, . . . ,a,b,c, ... ,z, . . .

Exemple
"ABC" < "BCA" car 'A'<'B'
"ABC" < "B" car 'A'<'B'
"Abc" < "abc" car 'A'<'a'
"ab" < "abcdZ" car " " < "cd

85
 8. CHAINES DE CARACTERES

Ordre alphabétique (lexicographique) des chaînes de caractères:

 Il existe une fonction en C, strcmp de la bibliothèqe

string.h, indique l’ordre lexicographique de deux chaînes
de caractères.

Syntaxe: int strcmp(chaine 1, chaine 2);

strcmp retourne:
1. un nombre positif si chaine 2 précède chaine 1 dans
l’ordre alphabétique
2. Un nombre négatif si chaine 1 précède chaine 2 dans
l’ordre alphabétique
3. Zéro si chaine 1 est identique à chaine 2

86
 8. CHAINES DE CARACTERES

Autres fonctions de manipulation de chaînes de caractères:

bibliothèque <string.h>

87
 8. CHAINES DE CARACTERES

Exercice 1

 Ecrire un programme qui demande à l’utilisateur de saisir

la chaine BONJOUR ETUDIANTS SMA et l’affiche.

Exercice 2

 Ecrire un programme qui calcule sans utiliser une fonction

de <string>, la longueur d’une chaine de caractères saisie.

88
 8. CHAINES DE CARACTERES

Exercice 3

 Ecrire un programme qui vérifie sans utiliser une fonction

de <string>, si une chaine CH introduite au clavier est un
palindrome.
Rappel:
Un palindrome est un mot qui reste le même qu’on le lise
de gauche à droite ou de droite à gauche.
Exemple:
SMIA n’est pas un palindrome
OTTO est un palindrome
12321 est un palindrome

89
Chapitre 9 : POINTEURS

90
 9. Les pointeurs

 Il existe deux manières d'utiliser une variable

1. Par son nom adressage direct
– compilateur réserve de la mémoire pour la variable
– exemple: int i =35;
2. Par son adresse adressage indirect
– une variable de type pointeur contient l'adresse d'une
autre variable
– Le lien entre pointeur et la variable pointée est géré
par le programmeur
Exemple:
int i =35;
int * p = &i;
91
 9. Les pointeurs

Exemple:
int i =35;
int * p = &i;

92
 9. Les pointeurs

Déclaration d'un pointeur

 type * nom_du_pointeur
Exemples
char *pc; // on déclare un pointeur sur une variable de type char
 int *pi; // pointeur sur entier
float *pf; // pointeur sur réel
Initialisation d'un pointeur
 Un pointeur ne peut prendre qu’une adresse d'une variable
existant en mémoire
Il doit pointer vers une zone mémoire réservée par le
compilateur comme étant une variable

93
 9. Les pointeurs

Utilisation de l'opérateur d'adressage &

int a;
int *pa,*pi;
pa = &a; //pa prend comme valeur l’adresse de a, donc pa pointe sur a
pi = pa; //pi et pa pointe sur la même adresse ( &a)

Utilisation de l'opérateur d'indirection *

• L’opérateur * donne le contenu de la variable pointée par un
pointeur

94
 9. Les pointeurs

Exemple1
int i =8;
int *pi;
pi = &i;
printf(" le contenu du pointeur est %d: \n",*p);
*pi = 19;
printf(" le nouveau contenu du pointeur est %d: \n",*p);

95
 9. Les pointeurs

Exemple1
int i = 35, j;
int *p, *q;
p = &i; //*p = 35
j = *p; //j = 35
*p = 10; // *p=i=10
i= 20; // i=*p=20
(*p)++; /* est équivalent à i++, donc i=*p= 21 */
q = p; // p et q pointent maintenant ensemble vers la même adresse
i=50 ; // i=*p=*q= 50

96
 9. Les pointeurs
Tableaux et pointeurs

Tout tableau en C est un pointeur constant sur son premier élément.

 Nom du tableau = adresse du premier élément du tableau
Exemple: int Tab [10]; //Tab &Tab[0]
 Les éléments du tableau sont stockés de façon contigüe on a:
Tab+ 1 &Tab[1]
Tab+ 2 &Tab[2]
En général Tab+ i &Tab[i]
 *(Tab+i) donne le contenu de l’adresse du ième élément du tableau
(Tab[i])

97
 9. Les pointeurs
Tableaux et pointeurs

Exemple:
int Tab[5] = {20, 2,-10, 3, 6};
*Tab Tab[0] = 20
*(Tab + 4) Tab[4]= 6
Tab +1 &Tab[1]

98
 9. Les pointeurs
Tableaux et pointeurs

Exemple:

99
 9. Les pointeurs
Tableaux et pointeurs

Remarque:
Le nom d’un tableau est une pointeur constant sur son premier élément donc
l’expression Tab ++ (ou bien Tab = Tab +1) n’est pas autorisé
int tab[10];
int *P;
l'instruction: P = tab; est équivalente à P = &tab[0];

P+i : pointe sur la ième composante du tableau elle est équivalente à &tab[i],
avec i varie de 0 à9 dans l’exemple.
*(P + i) : est le contenu du ième élément du tableau tab c'est-à-dire tab[i].

100
 9. Les pointeurs
Tableaux et pointeurs

Exemple2:

101
 9. Les pointeurs
Tableaux et pointeurs

Exemple2:

102
 9. Les pointeurs
Pointeurs et chaînes de caractères

char *p= "Hello world";

‘p’ prend comme valeur l’adresse du début de la chaîne "Hello world" non pas la
chaîne.

Exemple: affichage d’une chaine de caractères à l’aide d’un pointeur

char * p = "Hello world";
for (p ; *p != '\0'; p++) // ou for (p;*p;p++)
printf("%c ", *p);

103
 9. Les pointeurs
Pointeurs et chaînes de caractères

char * p = "Hello world"; //(1)

char * q= "Salut"; //(2)
q=p ; //(3)
La représentation graphique de ces instructions est la suivante :

104
 9. Les pointeurs
Pointeurs et chaînes de caractères

char tab[] = "Hello world"; char tab[] = "Hello world";

tab= "Salut"; // erreur strcpy(tab,"Salut"); //correct

105
 9. Les pointeurs
Tableau de pointeurs

Déclaration d'un tableau de pointeurs:

<Type> *<NomTableau>[<N>] : déclare un tableau <NomTableau> de <N>
pointeurs sur des données du type <Type>.

Exemple:
double *A[4]; /* un tableau de 4 pointeurs sur des réels du type double dont les
adresses et les valeurs ne sont pas encore définies*/

106
 9. Les pointeurs
Tableau de pointeurs

char *JOUR[7] = {“dimanche", “lundi", “mardi", “mercredi", “jeudi",

“vendredi", “samedi"};
/* un tableau JOUR[ ] de 7 pointeurs sur char. Chacun des pointeurs est
initialisé avec l'adresse de l'une des 7 chaînes de caractères.*/

107
 9. Les pointeurs
Tableau de pointeurs

// Pour afficher les 7 chaines

int i;
for (i=0; i<7; i++)
puts(JOUR[i]);
/*Pour afficher les premières lettres
des jours de la semaine*/
int i;
for (i=0; i<7; i++)
printf("%c\n", *JOUR[i] );
/* Pour afficher la deuxième lettre des
jours de la semaine*/
int i;
for (i=0; i<7; i++)
printf("%c\n", *(JOUR[i]+1) );
108
 9. Les pointeurs
Allocation dynamique de la mémoire

Exemple

109
 9. Les pointeurs
Allocation dynamique de la mémoire

Tableaux à deux dimensions (matrices)

 Si on ne connaît pas les dimensions du tableau :

ex : double ** tab; /* Il faut ensuite allouer un espace mémoire au tableau */
int L, C;
printf(« donner le nombre de lignes et de colonnes :\n »);
scanf(« %d%d »,&L,&C);

/* Allocation de mémoire pour la première dimension */

tab = (double**) malloc(L*sizeof(double*)); //On alloue les lignes de tab

/*Allocation de mémoire pour la seconde dimension */

for(i = 0 ; i <L ; i++) //pour chaque ligne de tab on alloue les colonnes
tab[i] = (double *) malloc(C*sizeof(double));
110
 9. Les pointeurs
Allocation dynamique de la mémoire

 La fonction calloc dont le prototype est:

void * calloc( unsigned N, unsigned taille_type);
réserve N éléments de taille_type octets chacun. Elle retourne un pointeur
générique sur le premier octet ainsi alloué ou NULL si l’allocation n’a pu
réussi.
L'espace alloué est initialisé à 0.
Exemple:
float *F;
F = (float *)calloc(25, sizeof(float)); // réserve 25*sizeof(float) octets initialisés
à 0.0

111
 9. Les pointeurs
Réallocation dynamique de la mémoire

 La réallocation de la mémoire se fait à l’aide de la fonction realloc:

void * realloc( void *bloc, unsigned taille);
Cette fonction permet de changer la taille affectée au bloc de mémoire fourni
par un précédent appel à malloc() ou calloc().
void *bloc : un pointeur vers un espace mémoire qui avait été dynamiquement
alloué au préalable, via la fonction malloc ou une fonction équivalente.
 taille: la nouvelle taille que nous souhaitons ajouter à notre bloc mémoire.
 En cas de succès, la fonction realloc retourne un pointeur sur la nouvelle zone
mémoire allouée

112
 9. Les pointeurs
Réallocation dynamique de la mémoire

 Exemple:
int N, *Tab;
printf("donner N: \n");
scanf("%d",&N);
Tab = (int *) malloc(N*sizeof(int));
if(Tab !=Null) // faire des traitements
Tab = (int *) realloc(Tab, 20*sizeof(int));
if(tab != NULL) // Utilisation de l'espace mémoire ré-alloué
else // Echec de la ré-allocation mémoire

113
 9. Les pointeurs
Libération de la mémoire allouée

Pour libérer un espace mémoire déjà alloué par la fonction malloc, on utilise la
fonction free dont le prototype est le suivant :
void free(void *pointeur);
elle prend en paramètre un pointeur sur l'espace mémoire à libérer

114
 9. Les pointeurs
Libération de la mémoire allouée

Exemple:
main( )
{
int nombre_elements;
scanf(“%d”,&nombre_elements);
int *tab = (int *)malloc(nombre_elements*sizeof(int));
if(tab != NULL) {
int i;
for(i=0 ; i<nombre_elements ; i ++)
scanf(“%d”, (tab+i));
for(i=0; i<nombre_elements ; i++)
printf("%d\n", *(tab+i));
free(tab);
}
else printf("Echec de l'allocation mémoire\n");
}

115
 9. Les pointeurs
Intérêts des pointeurs

L’utilisation des pointeurs est indispensable car ils sont étroitement

liés à la représentation des tableaux.
• Allouer et libérer de la mémoire dynamiquement, ce qui permet la
gestion de structures de taille variable, par exemple tableau de
taille variable
• Permettre le passage par adresse des paramètres des fonctions
afin de changer leur valeurs
• Réaliser des structures de données récursives (par exemple:
Listes chainées)

116
 9. Les pointeurs
Intérêts des pointeurs

L’utilisation des pointeurs est indispensable car ils sont étroitement

liés à la représentation des tableaux.
• Allouer et libérer de la mémoire dynamiquement, ce qui permet la
gestion de structures de taille variable, par exemple tableau de
taille variable
• Permettre le passage par adresse des paramètres des fonctions
afin de changer leur valeurs
• Réaliser des structures de données récursives (par exemple:
Listes chainées)

117
 8. Les fonctions et procédures

La programmation modulaire

Un programme écrit d'un seul tenant est difficile à comprendre dès qu'il dépasse une ou
deux pages.

Une écriture modulaire permet de scinder le programme en plusieurs parties et de

regrouper dans le programme principal les instructions décrivant les enchaînements.

La programmation modulaire permet d'éviter les séquences d'instructions répétitives et

permet le partage d'outils communs qu'il suffit d'avoir écrits et mis au point une seule fois.

118
 8. Les fonctions et procédures
Définition

Une fonction ou procédure ou encore sous programme est une suite d'instructions
élémentaires, mais vue du programme principal main().

Une fonction est caractérisée par un appel et un retour.

Le retour s'effectue après la dernière action de la fonction appelée et le programme

continue juste après l'appel de la fonction..

Une fonction peut appeler une autre fonction. Le nom donné à une fonction doit être
représentatif de la fonction réalisée (exemple : perimetre_cercle pour une procédure
calculant le périmètre d'un cercle).

119
 8. Les fonctions et procédures
Définition

Le programme principal main() et les fonctions ont besoin de se communiquer des valeurs.
Lors d'un appel d'une procédure les valeurs passées sont les paramètres d'entrée et à la fin
d'une fonction les paramètres renvoyés sont les paramètres de sortie.

120
 8. Les fonctions et procédures
Les procédures

Une procédure est un ensemble d'instructions portant un nom. Pour définir une procédure,
on utilise la syntaxe:

Void nomprocedure ()
{
/*
Instructions
*/
}

Une procédure est une nouvelle instruction, il suffit pour l'exécuter d'utiliser son nom. Par
exemple, pour exécuter une procédure appelée pr, il suffit d‘écrire pr().

121
 8. Les fonctions et procédures
Les procédures
Exemples
Le premier programme est écrit sans procédure:

# include <stdio.h>
int main()
{
printf("Bonjour\n");
return 0;
}

122
 8. Les fonctions et procédures
Les procédures
Exemples
Et dans le deuxième, le printf est placé dans la procédure afficheBonjour et cette procédure
est appelée depuis le main.

# include <stdio.h>
Void afficheBonjour ()
{
printf("Bonjour\n");
}
int main()
{
afficheBonjour ();
return 0;
}
123
 8. Les fonctions et procédures
Les procédures
Variables locales
Une procédure est un bloc d'instructions et est sujette aux mêmes règles que main. Il
estdonc possible de déclarer des variables :
void nomprocedure ( )
{
/*
déclaration de variables
*/
/*
instructions
*/
}

124
 8. Les fonctions et procédures
Les procédures
Variables locales

Attention, ces variables ne sont accessibles que dans le corps de la procédure, cela
signifie qu'elle naissent au moment de leur déclaration et qu'elles sont détruites une fois
la dernière instruction de la procédure exécutée. C'est pour cela qu'on les appelle des
variables locales.

Une variable locale n'est visible qu'entre sa déclaration et l'accolade fermant la

procédure.

125
 8. Les fonctions et procédures
Les procédures
Variables locales
Exemple, ce code est illégal :

# include <stdio.h>
void maprocedure ( )
{

Char a=b;
}
int main()
{
Char b = ‘k’;
printf("%c, %c\n",a,b);
return 0;
}

126
 8. Les fonctions et procédures
Les procédures
Variables locales
La variable b est déclarée dans la procédure main, et n'est donc visible que dans cette même
procédure. Son utilisation dans maProcedure est donc impossible. De même, la variable a est
déclarée dans maProcedure, elle n'est pas visible dans le main.

Voici un exemple d'utilisation de variables locales :

# include <stdio.h>
void unAdix ( )
{

int i;
for (i=0;i<=10;i++)
printf(" %d \n ",i);
}
int main()
{
unAdix();
return 0;
} 127