Cours Algo-Pro2 - LE-Informatique - Partie I

Télécharger au format pdf ou txt
Télécharger au format pdf ou txt
Vous êtes sur la page 1sur 65

LE.

Spécialité Enseignement Secondaire-Informatique (S3)

Module : ALGORITHMIQUE ET PROGRAMMATION 2

Année universitaire : 2021/ 2022

Professeur : SAMIR EL KADDOUHI

• Ecole Normale Supérieure de Meknès


Chapitre 1 : Rappels
✓ Structure d’un programme en C
✓ Variables
✓ Expressions et opérateurs
✓ Entrées-sorties
✓ Structures de contrôle
Introduction
Les langages de programmation
❑ Langages Bas niveau : proche de la machine, instructions élémentaires
▪ Langage machine, Assembleur
❑ Langages Haut niveau (langages évolués) : proche de l’homme, vocabulaire et syntaxe plus riches
▪ Langages procéduraux: C, Fortran, Pascal, …
▪ Langages orientés objets: C++, Java,…
❑ Nécessité d’un traducteur (compilateur/interpréteur) pour les langages évolués

Code source Compilateur ou


Langage machine
en langage évolué interpréteur

▪ Compilateur: traduire le programme entier une fois pour toutes


exemple.c Compilateur exemple exécution
fichier source fichier exécutable
▪ Interpréteur: traduire au fur et à mesure les instructions du programme à chaque exécution
Interprétation+exécution
exemple.bas
fichier source 3
• ENS de Meknès
Introduction
Langage C

❑ Inventé en 1972 dans «Bell Laboratories » (Etats-Unis) par Dennis


Ritchie et Ken Thompson.
❑ C’est un langage :
▪ Universel : n'est pas orienté vers un domaine particulier.
▪ Modulaire: peut être découpé en modules qui peuvent être compilés séparément.
▪ Portable: possibilité d'utiliser le même programme sur plusieurs systèmes (hardware,
système d'exploitation ).
▪ Utilisé dans la programmation système et la robotique : il est à la base des plus grands
systèmes d'exploitation (Unix, Linux, Mac OS).

4
• ENS de Meknès
Structure d’un programme en C
Structure d’un programme en C
❑ Un programme en C se présente en général sous la forme suivante :

<Directives de compilation>
<Déclaration de variables externes>
<Déclaration de prototypes de fonctions>
main ( ){
corps du programme
(commentaires, déclaration de variables et constantes, instructions)
}
<Définition de fonctions>

5
• ENS de Meknès
Structure d’un programme en C
Les directives de compilation
❑ Nous en citons les directives include et define:
▪ #include <fichier> : Indique le fichier de bibliothèque C à inclure dans le programme. Ce fichier contient
les définitions de certaines fonctions prédéfinies utilisées dans le programme. Ces fichiers sont organisés de
façon thématique :
• math.h : contient les déclarations des fonctions mathématiques;
• stdio.h : contient les déclarations des fonctions standard d’entrée sortie comme printf et scanf.
▪ #define: Permet de remplacer un symbole par une constante ou un type.

Les commentaires

Lorsqu'un programme devient long et compliqué, il est conseillé d'ajouter des lignes de commentaires dans
le programme pour expliquer le fonctionnement du programme sans que le compilateur ne les prenne en
compte. Pour ce faire, il faut placer vos commentaires entre les délimiteurs /* et */. Ou bien utiliser le
symbole // avant un commentaire (ne concerne qu’une seule ligne).

6
• ENS de Meknès
Les variables
Définition
❑ Une variable désigne un emplacement mémoire dont le contenu peut changer au cours d’un programme.
❑ Elles servent à stocker les valeurs des données utilisées pendant l’exécution d’un programme.
❑ Une variable est caractérisée par :
▪ Un nom (Identificateur) : constitué de lettres, de chiffres et du caractère de soulignement ( _ ) qui peut
remplacer des espaces
▪ Un type (entier, réel, …) : l’ensemble des valeurs qu’elle peut prendre.
▪ Une valeur.
❑ En langage C, il n’y a que 2 types de base : les entiers et les réels avec différentes variantes pour chaque type.
▪ Types Entier : 4 variables d’entiers:
• char : caractères (entier sur 1 octet)
• short ou short int : entier court (entier sur 2 octets)
• int : entier standard (entier sur 2 ou 4 octets)
• long ou long int : entier long (4 octets)
▪ Types Réel : 3 variables de réels:
• float : réel simple précision codé sur 4 octets
• double : réel double précision codé sur 8 octets
• long double : réel très grande précision codé sur 10 octets 7
• ENS de Meknès
Les variables
Déclaration de variables
❑ La déclaration introduit les variables qui seront utilisées, leur type et parfois aussi leur valeur de départ
(initialisation).
❑ Syntaxe :
Type NomVar1, NomVar2,..., NomVarN;
❑ Exemples :
int i; /* i est une variable de type entier */
float j,k; /* j et k sont des variables de type réel */
char c; /* c est une variable de type caractère */

Initialisation de variables
❑ Une valeur initiale peut être affectée à une variable dès la déclaration
❑ Syntaxe :
▪Cas de types numériques : Type Identificateur = Valeur numérique ;
▪Cas du type caractère : Type Identificateur = 'caractère’ ; Ou Type Identificateur = code ASCII d'un caractère ;
❑ Exemples
int i, j=3, k; /* seul j est initialisé à 3*/
float f=1.2 e5; /* f est initialisé à 120000 (1.2*105)*/
char c='A'; /* c est initialisé à la lettre A*/
char c=65; /* c est initialisé à A dont le code ASCII est 65*/
8
• ENS de Meknès
Les constantes
Définition et déclaration
❑ Définition :
▪ Une constante est une zone mémoire qui conserve sa valeur pendant toute l’exécution
d’un programme.
❑ Déclaration :
▪ On associe une valeur à une constante en utilisant :
• la directive #define : #define nom_constante valeur;
• le mot clé const : const type nom_constante = valeur;
❑ Exemples :
#define Pi 3.14; (la constante ne possède pas de type)
#define ENS "Ecole Normale Supérieure";
const float Pi =3.14; (la constante est typée)

9
• ENS de Meknès
Expressions et opérateurs
Définition
❑ Expression :
▪ Une expression est un calcul qui donne une valeur comme résultat. Elle peut être une valeur, une variable ou
une opération.
▪ Exemples : 1, b, a*2, a+ 3*b-c, …
❑ Opérateur :
▪ symbole qui permet de manipuler des variables (opérandes) pour produire un résultat.
▪ On distingue :
• les opérateurs binaires : nécessitent deux opérandes (ex : a + b)
• les opérateurs unaires : nécessitent un seul opérande ( ex: a++)
• l'opérateur conditionnel ? : nécessite trois opérandes.
❑ Exemples d’opérateurs :
▪ opérateurs arithmétiques : +, -, *, /, % (modulo)
▪ opérateurs d’affectation : =, +=, -=,*=,/=,…
▪ opérateurs logiques : &&, ||, !
▪ opérateurs de comparaison : ==, !=, <, >, <=, >=
▪ opérateurs d’incrémentation et de décrémentation : ++, --
▪ opérateurs sur les bits : &, |, ~, ^, <<, >>
▪ autres opérateurs particuliers : ?: , sizeof , cast , …
10
• ENS de Meknès
Les opérateurs
Les opérateurs d’affectation : =, +=, -=,*=,/=,…
❑ L'affectation est l'opération qui attribue à une variable, au moyen de l'opérateur =, une valeur constante ou
résultat d'une expression.
❑ Opérateurs d'affectation étendu:
▪ Soit un opérateur de calcul op, exp1 et exp2 deux expressions, alors :
exp1 op= exp2;  exp1= exp1 op exp2;
❑ Exemples :
▪ i=2; j=(i*3)+5; /* i reçoit 2 puis j reçoit 11 résultat de (2*3)+5*/
▪ i=j=2; /*j reçoit d'abord 2 puis i reçoit la valeur de j (2)*/
▪ i += 1;  i = i + 1;
▪ j -= 2 ;  j = j - 2 ;
▪ p *= i ;  p = p * i ;
▪ x /= 2 ;  x = x / 2 ;
▪ y %= 2 ;  y = y % 2;

11
• ENS de Meknès
Les opérateurs
Les opérateurs arithmétiques : +, -, *, /, % (modulo)
❑ Les opérandes peuvent être des entiers ou des réels sauf pour % qui agit uniquement sur des entiers.
❑ L'opérateur + permet de calculer l’addition.
❑ L'opérateur - permet de calculer la soustraction.
❑ L'opérateur * permet de calculer la multiplication.
❑ L'opérateur / permet de calculer la division. Il retourne un quotient entier si les deux opérandes sont entiers et
un quotient réel si l’un au moins des opérandes est un réel.
❑ L'opérateur % permet d'obtenir le reste de la division entière.
❑ Exemple :
▪ L’expression 11 / 2 retourne la valeur 5
▪ L’expression 11 / 2.0; retourne la valeur 5.5
▪ L’expression 11.0 / 2; retourne la valeur 5.5
▪ L’expression 11.0 / 2.0; retourne la valeur 5.5
▪ L’expression 11%2 retourne la valeur 1
▪ L’expression 10%2 retourne la valeur 0

12
• ENS de Meknès
Les opérateurs
Les opérateurs arithmétiques : +, -, *, /, % (modulo)
Conversion de type
❑ Lorsque les types des deux opérandes sont différents il y’a conversion implicite dans le type le plus fort.
❑ La conversion implicite se fait comme suit :
int → long → float → double → long double.
❑ NB: (short et char sont convertis en int).
❑ Opérateur de forçage de type (cast)
▪ Il est possible d’effectuer des conversions explicites (casting) ou de forcer le type d’une expression.
▪ Syntaxe : (type) expression;
❑ Exemple :
int i=9,j=4,k; /*i, j et k entiers*/
float x=9.0, y; /*x et y réel*/
k=x+j; /*k reçoit 13.0 */
y=i/j; /*y reçoit 2.0 (division entière : i et j entiers)*/
y=x/j; /*y reçoit 2.25 (division réelle : x réel*/
y=9.0/j; /*y reçoit 2.25 (division réelle : 9.0 réel*/
k=i%j; /*k reçoit 1 (reste de la division de i par j)*/
y=(float) i / j; /*y reçoit 2.25 (i est converti d'abord en réel=9.0)*/
y=(float) (i/j); /*y reçoit 2.0 (l'entier 2 (i/j) est converti en réel)*/
13
• ENS de Meknès
Les opérateurs
Les opérateurs de comparaison : ==, !=, <, >, <=, >=
❑ Les opérateurs de comparaison retournent la valeur 0 si la comparaison est fausse et 1 sinon.
• == : égalité.
• != : différent.
• < : inférieur.
• <= : inférieur où égal.
• > : supérieur.
• >= : supérieur où égale.
❑ Exemples :
• 2<5 retourne 1, 2==5 retourne 0, 2!=5 retourne 1, 2>5 retourne faux (0)

Les opérateurs logiques : &&, ||, !


Opérateurs Signification
! Non logique
&& ET logique
// OU logique
❑ S'appliquent à des expressions booléennes (0 si faux et valeur non nulle si vrai)
❑ ET (&&) retourne la valeur 1 si les deux opérandes sont non nuls, et 0 sinon.
❑ Ou (||) retourne la valeur 1 si au moins un des opérandes est non nul, et 0 sinon.
❑ Exemples
• 32 && 40 retourne 1
• !65.34 retourne 0
• !(12>2) retourne 0
• (5<7)//(3>6) retourne 1
• (2<6) &&(4>5) retourne 0
14
• ENS de Meknès
Les opérateurs
Les opérateurs d’incrémentation et de décrémentation : ++, --
❑ Ils permettent d'incrémenter ou de décrémenter une variable. L'opérateur ++ (--) effectue une pré
incrémentation (pré décrémentation) ou une post-incrémentation (post décrémentation) selon son emplacement
après ou avant la variable.
❑ Dans une opération d'affectation qui met en jeu l'opérateur de :
▪ Pré-incrémentation (pré-décrémentation), la variable est d'abord incrémentée (décrémentée) de 1.
L'affectation est ensuite effectuée.
▪ Post-incrémentation (post-décrémentation), L'affectation (sans les ++ (--)) est effectuée avant
l'incrémentation (décrémentation).
❑ Exemples :
Soient i=3 et j=5,
Instruction Equivalent Résultats
i++; i=i+1; i=4
++i; i=i+1; i=4
i--; i=i-1; i=2
--i; i=i-1; i=2
i= ++j; j=j+1; i=j; j=6 et i=6
j= ++i + 5; i=i+1; j=i+5; i=4 et j=9
j= i++ + 5; j=i+5; i=i+1; j=8 et i=4
15
• ENS de Meknès
Les opérateurs
Priorités des opérateurs en C

16
• ENS de Meknès
Les opérateurs
Opérateur conditionnel ?:
❑ Syntaxe : exp1 ? exp2 : exp3
exp1 est évaluée, si sa valeur est non nulle c’est exp2 qui est exécutée, sinon exp3 qui est exécutée.
❑ Exemple 1 :
max = (a > b) ? a : b;
Si a>b alors on affecte à max le contenu de a, sinon on lui affecte b.
❑ Exemple 2 :
int i=10;
(a > b) ? i++ : i--;
Si (a>b) on incrémente i sinon on décrémente i.

Opérateur SIZEOF
❑ Fournit la taille en octets d'un type ou d'une variable.
❑ Syntaxe : sizeof (type); ou sizeof (variable);
❑ Exemples :
double n;
printf ("%d \n",sizeof(int)); affiche 4
printf ("%d \n",sizeof(n)); affiche 8
17
• ENS de Meknès
Les fonctions mathématiques

❑ Les fonctions mathématiques sont déclarées dans le fichier math.h


❑ Pour pouvoir utiliser les fonctions mathématiques, il faut utiliser l’entête #include<math.h>.
❑ Soient x et y deux variables de type double, Voici la liste des fonctions les plus courantes :

sin(x) : sinus de x exp(x) : exponentielle de x (ex)


cos(x) : cosinus de x log(x) : logarithme népérien de x (ln(x), x>0)
tan(x) : tangente de x log10(x) : logarithme à base 10 (log10(x), x>0)
asin(x) : arc sinus de x pow(x,y) : x exposant y (x^y ) (Il se produit une erreur si
acos(x) : arc cosinus de x x=0 et y=0, ou si x<0 et y n'est pas un entier)
atan(x) : arc tangente de x sqrt(x) : racine carrée de x
sinh(x) : sinus hyperbolique de x fabs(x) : valeur absolue de x (|x|)
cosh(x) : cosinus hyperbolique de x floor(x) : le plus grand entier inférieur ou égal à x
tanh(x) : tangente hyperbolique de x ceil(x) : le plus petit entier supérieur ou égal à x

18
• ENS de Meknès
Entrées/sorties
Introduction
❑ Les instructions de lecture et d’écriture permettent à la machine de dialoguer avec l’utilisateur.
❑ La bibliothèque standard <stdio.h> contient un ensemble de fonctions qui assurent la lecture et
l’écriture des données.
❑ Les principales fonctions qui assurent la lecture et l’écriture des données sont :
▪ printf() : pour l’écriture formatée de données.
▪ scanf() : pour la lecture formatée de données.

19
• ENS de Meknès
Entrées/sorties
Printf()
❑ Syntaxe : printf("format", expr1, expr2, …);
▪ expr1,… : variables et expressions dont on veut afficher la valeur .
▪ Format : chaîne de caractères qui peut contenir :
• du texte.
• des séquences d’échappement (\n, \t, \r …).
• des spécificateurs de format : indiquant le format d’affichage :

❑ Exemple:

20
• ENS de Meknès
Entrées/sorties
Scanf()
❑ Syntaxe : scanf("format", AdrVar1, AdrVar2, …);
▪ Format : format de lecture de données (le même que pour printf).
▪ adrVar1, adrVar2, … : adresses des variables auxquelles les données seront attribuées. Ces
adresses sont indiquées par le nom des variables précédé du signe &.
❑ Exemple :
un programme qui permet de lire deux entiers entrés au clavier et les afficher :

21
• ENS de Meknès
Structures de contrôle
Introduction
❑ Les structures de contrôle conditionnent l'exécution des instructions en fonction de la valeur d'une
expression.
❑ On distingue deux types de structures de contrôle :
▪ structures alternatives (tests) : permettent d’effectuer des choix : if … else et switch.
▪ structures répétitives (boucles) : permettent de répéter plusieurs fois l’exécution d’un ensemble
d’instructions : while, do…while et for.

22
• ENS de Meknès
Structures de contrôle
Structures alternatives (tests): if…else et switch
❑ Structure if…else :
if (expression) {bloc-instruction-1}
else {bloc-instruction-2}
▪ L'instruction if sélectionne le traitement (bloc d'instructions) à faire si une condition est vérifiée.
▪ Lorsque if est utilisée avec else, elle indique également le traitement à faire si la condition n'est pas vérifiée.
▪ Si le traitement à effectuer est constitué d'une seule instruction, il est possible d'omettre les accolades.
▪ Exemples:
Exemple 1 Exemple 2
#include <stdio.h> #include <stdio.h>
main( ) main( )
{ {
int a,b; int a,b;
printf ("Introduire a et b : "); printf ("Introduire a et b : ");
scanf ("%d%d",&a,&b); scanf ("%d%d",&a,&b);
if (a==0) /*si a=0 affiche les messages zéro puis FIN*/ if (a==0) /*si a=0 affiche les messages zéro puis FIN*/
{ {
printf("zéro\n"); printf("zéro\n");
printf("FIN\n"); printf("FIN\n");
} }
if (a!=0) /*si a=1 affiche le message différent de zéro*/ else /*si a=1 affiche le message différent de zéro*/
printf(« différent de zéro\n"); printf(« différent de zéro\n");
} } 23
• ENS de Meknès
Structures de contrôle
Structures alternatives (tests): if…else et switch
❑ Imbrication des instructions if :
▪ On peut avoir plusieurs instructions if…else imbriquées les uns dans les autres, dans ce cas, un else est
toujours associé au if le plus proche et qui n’est associé à aucun else.
▪ Exemples:
#include <stdio.h>
main( )
{
int a,b;
printf ("Introduire a et b : ");
scanf ("%d%d",&a,&b);
if(a<=0)
if(a=0)
printf("a est nul ");
else
printf(" a est strictement négatif ");
else
printf(" a est strictement positif " );
}
24
• ENS de Meknès
Structures de contrôle
Structures alternatives (tests): if…else et switch
❑ L’instruction SWITCH
▪ Elle réalise un aiguillage vers différentes instructions en fonction du contenu d'une variable de contrôle.
▪ Le sélecteur de switch (la variable de contrôle) doit être un entier ou un caractère.
▪ Syntaxe :
switch (Variable de contrôle)
{
case Valeur1 : Traitement1 (bloc d'instructions); break;
case Valeur2 : Traitement2; break;

case Valeurn : Traitementn ; break;
default : Traitementm
}
▪ Exemple : #include <stdio.h>
main( )
{
int a;
printf ("Introduire un nombre: ");
scanf ("%d",&a);
switch (a) /*le programme traite tous les cas de a (0,1 ou autres)*/
{
case 0 : printf ("Le nombre introduit est zéro\n"); break;
case 1 : printf ("Le nombre introduit est 1\n"); break;
default : printf ("Le nombre introduit est différent de 0 et 1\n");
}
25
• ENS de Meknès
Structures de contrôle
Structures répétitives (boucles) : while, do …while et for
❑ Structure while :
▪ L'instruction while permet de répéter un traitement autant de fois qu'une condition est vérifiée.
▪ Syntaxe :
while (Condition)
{
Traitement (bloc d'instructions)
}
▪ Fonctionnement : Le système teste d'abord si la condition est vraie ; si oui, exécute le traitement et remonte
automatiquement à la ligne while pour tester de nouveau la condition. Elle s'arrête quand la condition devient
fausse.
▪ Exemple:

26
• ENS de Meknès
Structures de contrôle
Structures répétitives (boucles) : while, do …while et for
❑ Structure do … while :
▪ L'instruction do while permet de répéter un traitement jusqu'à ce qu'une condition ne soit plus vérifiée.
▪ Syntaxe :
do
{
Traitement (bloc d'instructions)
}
while (Condition);
▪ Fonctionnement : Le système exécute d'abord le traitement puis teste si la condition est vraie ; si oui, il
remonte automatiquement à la ligne do pour exécuter de nouveau le traitement. Il s'arrête quand la condition
devient fausse.
▪ Exemple:

27
• ENS de Meknès
Structures de contrôle
Structures répétitives (boucles) : while, do …while et for
❑ Structure for :
▪ L'instruction for permet de répéter un traitement donné un nombre de fois précis.
▪ Syntaxe :
for (Initialisations; Condition; Instructions)
{
Traitement (bloc d'instructions)
}
▪ Fonctionnement : For commence au départ, par effectuer les initialisations (en premier argument), exécute
le traitement tant que la condition (en deuxième argument) est vérifiée et exécute les instructions (en
troisième argument) à chaque fin d'itération.
▪ Exemple:

28
• ENS de Meknès
Structures de contrôle
Les instructions break et continue
❑ break :
▪ peut être utilisée dans une boucle (for, while, ou do .. while) pour arrêter le déroulement de la boucle et
passer à la première instruction qui la suit .
▪ En cas d’imbrication de boucles, break ne quitte que la boucle (ou le switch) le plus interne..
▪ Exemple :

❑ continue :
▪ peut être utilisée dans une boucle (for, while, ou do .. while) pour abandonner l’itération courante et
passer à l’itération suivante.
▪ Exemple :

29
• ENS de Meknès
Chapitre 2 : Les tableaux
✓ Tableaux unidimensionnels

✓ Tableaux multidimensionnels

✓ Les chaines de caractèrescaractères


Les tableaux
Caractéristiques
❑ Tableau : variable structurée composée d’un nombre de variables simples de même type
appelées éléments.
❑ Les éléments du tableau sont stockés en mémoire à des emplacements contigûs (l’un après
l’autre).
❑ Le type des éléments du tableau peut être :
▪ un type simple : char, int, float, double, …
▪ un pointeur.
▪ une structure.
❑ Un tableau peut être unidimensionnels ou multidimensionnel.

31
• ENS de Meknès
Les tableaux
Tableaux unidimensionnels
Déclaration
❑ Syntaxe de déclaration :
Type nom[dimension];
▪ Exemple :
int T1[10] ; // le compilateur réserve des places pour 10 entiers, soit 40 octets
float T2[20]; // le compilateur réserve des places pour 20 réels, soit 80 octets
❑ Initialisation à la déclaration :
Type nom[dimension] = {val1, val2, val3, …};
▪ Exemple :
int A[5] = {1, 2, 3, 4, 5};
int A[] = {1, 2, 3, 4, 5};
32
• ENS de Meknès
Les tableaux
Tableaux unidimensionnels
Manipulation
❑ Accès aux éléments d’un tableau :
▪ L'accès à un élément du tableau se fait au moyen de l'indice T[i].

❑ Affectation:
▪ Affectation d’une valeur à une case du tableau
T[0]=14 ;
T[1]=15 ;
▪ Affectation de la valeur d’une case de tableau à une variable
a= T[0] ;
▪ Affectation de valeurs à un tableau
int i, T[10] ;
for(i=0 ; i<10 ; i++)
T[i]=i ;
33
• ENS de Meknès
Les tableaux
Tableaux unidimensionnels
Manipulation
❑ Lecture des éléments du tableau:
▪ Lecture d’un seul élément :
scanf("%d",&T[2]);
▪ Lecture de tous les elements :
int i, T[10] ;
for(i=0 ; i<10 ;i++)
scanf("%d",&T[i]);

34
• ENS de Meknès
Les tableaux
Tableaux unidimensionnels
Manipulation
❑ Affichage des éléments du tableau:
▪ Affichage d’un seul élément
printf ("%d", T[3]);
▪ Affichage de tous les éléments
int i, T[10] ;
for(i=0 ; i<10 ;i++)
printf("%d\n",T[i]);

35
• ENS de Meknès
Les tableaux
Tableaux unidimensionnels
▪Exemple: Programme qui permet de saisir 10 réels, les ranger dans un tableau, puis calculer et
afficher la somme de ces réels.
#include <stdio.h> /* Affichage du tableau */
main() printf("Tableau donné :\n");
{ for (I=0; I<10; I++)
/* Déclarations */ printf("%.2f \t", T[I]);
float T[50]; printf("\n");
int I; /* Calcul de la somme */
float SOM; for (SOM=0, I=0; I<10; I++)
/* Saisie des données */ SOM += T[I];
for (I=0; I<10; I++) /* Affichage de la somme */
{ printf("Somme est :%.2f\n", SOM);
printf("Elément %d : ", I+1); }
scanf("%f", &T[I]);
}

36
• ENS de Meknès
Les tableaux
Tableaux multidimensionnels
Déclaration
❑ Un tableau multidimensionnel est un tableau qui contient des tableaux.
❑ Syntaxe :
Type Nom[d1][d2]…[dn];
❑ Les tableaux à deux dimensions ou matrices, sont rangés ligne par ligne et considérées comme
des vecteurs lignes.
▪ Exemple :
short A[2][3];
➢ A est un tableau comportant 2 éléments, chacun d'entre eux étant un tableau de 3 éléments.
➢ On peut représenter le tableau A de la manière suivante :

37
• ENS de Meknès
Les tableaux
Tableaux à deux dimensions
Manipulation
❑ Initialisation à la déclaration :
float A[3][4] = { {-1.5, 2.1, 3.4, 0},{8, 7.5,1, 2.7 }, {3.1, 0, 2, -1} } ;

❑ Saisie des éléments d’un tableau à 2 dimensions :

❑ Affichage des éléments d’un tableau à 2 dimensions :

38
• ENS de Meknès
Les tableaux
Tableaux à deux dimensions
❑Exemple: Saisir une matrice d'entiers 2x2, calculer et afficher son déterminant.

#include <stdio.h> /* Affichage du tableau */


main() printf("Tableau donné :\n");
{ for (i=0; i<2; i++)
/* Déclarations */ {
int A[2][2]; for (J=0; J<2; j++)
int i, j, det; printf("%d\t", A[i][j]);
/* Saisie des données */ printf("\n");
for (i=0; i<2; i++) }
for (j=0; j<2; j++) /* Calcul le déterminant */
{ det= A[0][0]*A[1][1]-A[0][1]*A[1][0];
printf("Element[%d][%d] : ", i, j); printf("le déterminant est : %d\n", det);
scanf("%d", &A[i][j]); }
}
39
• ENS de Meknès
Les chaines de caractères
Introduction
❑ En langage C, il n'existe pas de type spécial chaîne ou string.
❑ Pour cela, une chaîne de caractères est traitée en C comme un tableau de caractères.
❑ En C, une chaîne de caractères est caractérisée par le fait que le dernier élément vaut le caractère
‘\0’. Ceci permet de détecter la fin de la chaîne.

E N S M \0

40
• ENS de Meknès
Les chaines de caractères
Déclaration
❑ Syntaxe : char NomVariable [Longueur];
❑ Exemple : char NOM [15];
❑ Remarques :
▪ Pour une chaîne de N caractères, on a besoin de N+1 octets en mémoire (le dernier octet est
réservé pour le caractère ‘\0’).
▪ Le nom d’une chaîne de caractères est le représentant de l’adresse du 1er caractère de la
chaîne.

Initialisation
❑ On peut initialiser une chaîne de caractères à la définition par l’une des trois méthodes suivantes :
1) comme un tableau.
Exemple : char ch[] = {‘e’, ’c’, ’o’, ’l’, ’e’, ’\0’};
2) par une chaîne constante.
Exemple : char ch[] = "ecole";
41
• ENS de Meknès
Les chaines de caractères
Lecture et affichage
❑ Une variable de type chaîne de caractère peut être lue et affichée caractère par caractère au moyen
de scanf et printf en utilisant le format %c .
❑ Elle peut également être lue (affichée) globalement au moyen de la fonction scanf (printf) utilisant
cette fois-ci le format %S ou au moyen de la fonction gets (puts)
➢ Scanf("%S", chaine-de-caractere);
➢ printf("%S", chaine-de-caractere);
➢ gets(chaine-de-caractere) ;
➢ puts(chaine-de-caractere) ;

42
• ENS de Meknès
Les chaines de caractères
Lecture et affichage
❑ Exemple:

#include<stdio.h>
Main( )
{
Char CH[20];
scanf("%S", CH); /*on ne met pas d’adresse &*/
printf("%S", CH);
gets(CH); /*lecture*/
puts(CH); /*affichage*/
}

43
• ENS de Meknès
Les chaines de caractères
Fonctions de manipulation de chaînes
❑ Fonctions de la bibliothèque <string.h> :
Fonction Rôle Exemple

fournit la longueur de la chaîne sans compter le char ch[ ]= " Test";


strlen(ch)
'\0' printf(“%d”,strlen(ch)); //4
ajoute ch2 à la fin de ch1. Le ‘\0’ de ch1 est char ch1[20]=" Bonne", ch2=" chance ";
strcat(ch1, ch2) écrasé par le 1er caractère de ch2 strcat(ch1, ch2) ;
printf(" %s", ch1); //Bonne chance
compare ch1 et ch2 du point de vue strcmp ("bonjour", "monsieur");
lexicographique. //négatif
strcmp(ch1, ch2) retourne une valeur : nul si ch1 et ch2 sont strcmp ("paris2", "paris10"); // positif.
identiques, négative si ch1 précède ch2,
positive si ch1 suit ch2.
copie ch2 dans ch1 y compris le caractère ‘\0 char ch[10];
strcpy(ch1, ch2) strcpy(ch, " Bonjour ");
puts(ch); // Bonjour
44
• ENS de Meknès
Les chaines de caractères
Fonctions de manipulation de chaînes
strlen(ch)
❑ Exemple: Programme qui permet de lire un mot et de calculer sa taille

#include <stdio.h>
#include <string.h>
main()
{char mot[31];
printf(“donner un mot:\n”);
scanf(“%s”, mot);
printf(“la taille de %s est %d”, mot, strlen(mot));
}

45
• ENS de Meknès
Les chaines de caractères
Fonctions de manipulation de chaînes
strcmp( chaîne1,chaîne2):
❑ Exemple: Programme qui lit deux mots de moins de 30 lettres minuscules et qui indique s’ils sont ou non
dans l’ordre alphabétique:
#include<stdio.h>
#include <string.h>
main()
{char mot1[31],mot2[31];
int comp;
printf(“donner deux mots en minuscules:\n);
scanf(“%s%s”,mot1,mot2);
comp=strcmp(mot1,mot2);
if(comp<0) printf(“dans l’ordre alphabétique\n”);
if(comp==0) printf(“identiques”);
if(comp>0) printf(“ pas dans l’ordre alphabétique”);
}
46
• ENS de Meknès
Les chaines de caractères
Fonctions de manipulation de chaînes
strcpy(ch1,ch2)
❑ Exemple: Programme qui lit deux mots de moins de 30 lettres et d’échanger le contenu des deux chaînes

#include <stdio.h>
#include <string.h>
main()
{char mot1[31],mot2[31], mot[31];
printf("donner deux mots:\n");
gets(mot1);
gets(mot2);
printf("mot1 avant l'echange:%s\n",mot1);
printf("mot2 avant l'echange:%s\n",mot2);
strcpy(mot,mot1);
strcpy(mot1,mot2);
strcpy(mot2, mot);
printf("mot1 apres l'echange:%s\n",mot1);
printf("mot2 apres l'echange:%s\n",mot2);
}
47
• ENS de Meknès
Les chaines de caractères
Fonctions de manipulation de chaînes
❑ Fonctions de la bibliothèque <stdlib.h> :
❑ <stdlib> contient des fonctions pour la conversion de nombres en chaînes de caractères et vice-versa.
▪ atoi(ch): retourne la valeur numérique représentée par ch comme int
▪ atof(ch): retourne la valeur numérique représentée par ch comme float (si aucun caractère n’est valide,
ces fonctions retournent 0)
Exemple : int x, float y;
char *s= " 123 ", ch[]= " 4.56 ";
x=atoi(s); y=atof(ch); // x=123 et y=4.56
▪ itoa(int n, char * ch, int b) : convertit l’entier n en une chaîne de caractères qui sera attribué à ch. La
conversion se fait en base b
Exemple : char ch[30]; int p=18;
itoa(p, ch, 2); // ch= " 10010 ";
48
• ENS de Meknès
Les chaines de caractères
Tableaux de chaînes de caractères
❑ Utiles pour mémoriser une suite de mots ou de phrases.
❑ Exemples :
1. char Jour[7][9] = {"Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"} ;
Déclaration d'un tableau de 7 chaînes de caractères, chacune contenant au maximum 9 caractères
(dont 8 significatifs).
2. Jour[4] = "Friday" ; /* affectation non valide ! */
En effet Jour[4] représente l'adresse du 1er élément de la 4ème chaîne de caractères. Pour faire ce
type d'affectation, utiliser la fonction strcpy : strcpy(Jour[4], "Friday") ;
3. /* Affichage de la 1ère lettre des jours de la semaine */
for (i = 0 ; i<7 ; i++)
printf("%c\t", Jour[i][0]) ;
49
• ENS de Meknès
Chapitre 3 : Les pointeurs
✓ Les pointeurs

✓ Les pointeurs et les tableaux

✓ Les pointeurs et les chaines de caractères

✓ Allocation dynamique de la mémoire


Les pointeurs
Définition
❑ Un pointeur est une variable spéciale qui peut contenir l’adresse d’une autre variable.
❑ Exemple :
▪ A est une variable qui contient la valeur 10.
▪ P est un pointeur qui contient l'adresse de A (P pointe sur A).

❑ Remarques :
▪ Le nom d’une variable permet d'accéder directement à sa valeur → adressage direct.
▪ Un pointeur qui contient l'adresse de la variable, permet d'accéder indirectement à sa valeur →
adressage indirect.
❑ Intérêts:
▪ Permettent le passage par référence pour les paramètres des fonctions.
▪ Permettent d’allouer dynamiquement la mémoire.
▪ Permettent de créer des structures de données (listes, piles, files, arbres) dont le nombre
d’éléments peut évoluer de façon dynamique.
▪ Permettent d’écrire des programmes plus compacts et efficaces.
51
• ENS de Meknès
Les pointeurs
Déclaration
❑ Syntaxe : type *nom-du-pointeur ;
▪ type : c’est le type de la variable pointée.
▪ * : c’est l’opérateur qui indique au compilateur que c’est un pointeur.
❑ Exemples :
int *pi; //pi est un pointeur vers une variable de type int.
float *pf; //pf est un pointeur vers une variable de type float.
❑ Remarque :
La valeur d’un pointeur donne l’adresse du premier octet parmi les n octets où la variable est
stockée.

52
• ENS de Meknès
Les pointeurs
Initialisation
❑ À la déclaration d’un pointeur p (int *p; ), on ne sait pas sur quel zone mémoire il pointe. Ceci
peut générer des problèmes.
❑ Conseil : Toute utilisation d’un pointeur doit être précédée par une initialisation.
❑ On peut initialiser un pointeur en lui affectant :
▪ l’adresse d’une variable : Exemple : int a, *p1; p1=&a;
▪ un autre pointeur déjà initialisé : Exemple : int *p2; p2=p1;
▪ la valeur 0 désignée par le symbole NULL :
o Exemple : int *p; p=0;
ou p=NULL; (on dit que p pointe ‘nulle part’: aucune adresse).

53
• ENS de Meknès
Les pointeurs
Opérateurs de manipulation
❑ Lors du travail avec des pointeurs, nous utilisons :
▪ L’opérateur & : 'adresse de' : pour obtenir l'adresse d'une variable.
▪ L’opérateur * : 'contenu de' : pour accéder au contenu d'une adresse (un pointeur).
❑ Exemple 1 :

main()
{
int i = 3;
Affiche:
int *p;
la valeur de i est: 3
p = &i;
l'adresse de i est 6487572
printf("la valeur de i est: %d \n",*p);
printf("l'adresse de i est %d \n", p);
}

54
• ENS de Meknès
Les pointeurs
Opérateurs de manipulation
❑ Exemple 2 :
int * p; //on déclare un pointeur vers une variable de type int
int i=10, j=30; // deux variables de type int
p=&i; // on met dans p, l’adresse de i (p pointe sur i)
printf("%d \n",*p); //affiche le contenu de la case pointée par p (le contenu de i) : 10
*p=20; // met 20 dans la case pointée par p (i vaut 20 après l’instruction)
printf("%d \n",i); //affiche : 20
p=&j; // p pointe sur j
i=*p; // affecte le contenu de la case pointée par p (le contenu de j) à i (i vaut 30 après cette instruction)
printf("%d \n",i); //affiche : 30
❑ Exemple 3 :
float a, *p;
p=&a; Entrez une valeur :
printf("Entrez une valeur : \n"); 1.5
scanf("%f", p); //supposons qu’on saisit la valeur 1.5 Adresse de a= 62fe14, contenu de a= 1.50
printf("Adresse de a= %x, contenu de a= %.2f\n" , p,*p);

55
• ENS de Meknès
Les pointeurs
Opérations arithmétiques avec les 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.
❑ Exemple :
main() main() main()
{ { {
int i = 3, j = 6; int i = 3, j = 6; int i = 3, j = 6;
int *p1, *p2; int *p1, *p2; int *p1, *p2;
p1 = &i; p1 = &i; p1 = &i;
p2 = &j; p2 = &j; p2 = &j;
*p1 = *p2; p1 = p2;
} } }

56
• ENS de Meknès
Les pointeurs
Opérations arithmétiques avec les pointeurs
❑ La valeur d'un pointeur étant un entier, on peut lui appliquer un certain nombre d'opérateurs arithmétiques
classiques. Les seules opérations arithmétiques valides sur les pointeurs sont :
▪ l'addition d'un entier à un pointeur. Le résultat est un pointeur de même type que le pointeur de départ ;
▪ la soustraction d'un entier à un pointeur. Le résultat est un pointeur de même type que le pointeur de départ;
▪ la différence de deux pointeurs pointant tous deux vers des objets de même type. Le résultat est un entier
dont la valeur est égale à (différence des adresses)/sizeof(Type).
▪ Notons que la somme de deux pointeurs n'est pas autorisée.
❑ Exemples: main() {
main() { main() { int i = 3, j=2;
int i = 3; double i = 3; int *p1, *p2, *p3;
int *p1, *p2; double *p1, *p2; p1 = &i;
p1 = &i; p1 = &i; p2=&j;
p2 = p1 + 1; p2 = p1 + 1; p3 = p1 - p2;
printf("p1 = %d \t p2 = %d\n",p1,p2); printf("p1 = %d \t p2 = %d\n",p1,p2); printf("p1 = %d \t p2 = %d\t
} } p3=%d\n",p1,p2,p3);
}
Affiche p1 = 6487564 p2 = 6487568 p1 = 6487560 p2 = 6487568 p1 = 6487556 p2 = 6487552 p3= 1
57
• ENS de Meknès
Les pointeurs
Opérateurs d’incrémentation de décrémentation
❑ Si un pointeur P pointe sur une variable X, alors *P peut être utilisé partout où on peut écrire X
• X+=2 équivaut à *P+=2
• ++X équivaut à ++ *P
• X++ équivaut à (*P)++ // les parenthèses ici sont obligatoires car l’associativité des
opérateurs unaires * et ++ est de droite à gauche
❑ Exemple : main() {
int *p1;
int a =1;
p1=&a;
printf("Adresse p1 = %d \n",p1);
++*p1;
printf("a= %d \n",a);
p1++;
printf("Adresse p1 = %d\n",p1);
}
Adresse p1 = 6487572
a= 2
Adresse p1 = 6487576
58
• ENS de Meknès
Les pointeurs
Exercices
❑ Exercice 1 :
Trouvez les erreurs dans les suites d’instruction suivantes :
a) short *p , x = 34; *p = x;
*p = x est incorrect parce que le pointeur p n’est pas initialisé
a) long x = 17 , *p = x; *p = 17;
*p = x est incorrect. Pour que p pointe sur x à la déclaration, on écrit : *p = &x
a) double *q; long x = 17 , *p = &x; q = p;
q = p incorrect. q et p deux pointeurs sur des types différent
a) short x, *p; &x = p;
&x = p incorrect. &x n’est pas une variable (lvalue) et par conséquent l’expression
&x ne peut pas figurer à gauche d’une affectation.
59
• ENS de Meknès
Les pointeurs
Exercices
❑ Exercice 2 :
Qu’affiche le programme suivant:

main() {
float *p1, *p2;
float z =1.5;
p1=&z;
printf("Adresse p1 = %x \n",p1);
p1++;
p2=p1+1;
printf("Adresse p1 = %x \t Adresse p2 = %x\n",p1,p2);
printf("p2-p1 = %d \n",p2-p1);
}

Adresse p1 = 62fe0c
Adresse p1 = 62fe10 Adresse p2 = 62fe14
p2-p1 = 1

60
• ENS de Meknès
Les pointeurs
Exercices
❑ Exercice 3 :
Qu’affiche le code suivant

main() {
int a=3;
int b=10;
int c, *pa, *pb, *pc;
pa = &a; //pa pointe sur a
*pa = *pa * 2; //a=6
pb = &b; //pb pointe sur b
c = 3 * (*pb - *pa); // c=3*(10-6) = 12
pc = pb; //pc pointe sur b
pa = pb; //pa pointe sur b
printf("*pa = %d \t *pb = %d\t *pc = %d\t a= %d\t b = %d\t c = %d\n",*pa,*pb, *pc, a, b, c);
}

*pa = 10 *pb = 10 *pc = 10 a= 6 b = 10 c = 12

61
• ENS de Meknès
Les pointeurs
Exercices
❑ Exercice 4 :
Soir le programme suivant Complétez le tableau suivant pour chaque instruction du programme ci-dessus.
main() {
int A = 1; A B C P1 P2
int B = 2;
int C = 3;
Initialisation
int *P1, *P2; P1=&A; P2=&C;
P1=&A; *P1=(*P2)++;
P2=&C; P1=P2;
*P1=(*P2)++;
P1=P2; P2=&B;
P2=&B; *P1-=*P2;
*P1-=*P2; ++*P2;
++*P2;
*P1*=*P2;
*P1*=*P2;
A=++*P2**P1; A=++*P2**P1;
P1=&A; P1=&A;
*P2=*P1/=*P2; *P2=*P1/=*P2;
}

62
• ENS de Meknès
Les pointeurs
Exercices
❑ Exercice 4 :

A B C P1 P2
Initialisation 1 2 3
P1=&A; P2=&C; 1 2 3 &A &C
*P1=(*P2)++; 3 2 4 &A &C
P1=P2; 3 2 4 &C &C
P2=&B; 3 2 4 &C &B
*P1-=*P2; 3 2 2 &C &B
++*P2; 3 3 2 &C &B
*P1*=*P2; 3 3 6 &C &B
A=++*P2**P1; 24 4 6 &C &B
P1=&A; 24 4 6 &A &B
*P2=*P1/=*P2; 6 6 6 &A &B

63
• ENS de Meknès
Les pointeurs
Exercices
❑ Exercice 5 :
Ecrire un programme qui vérifier si un nombre est pair ou impair. Utiliser le formalisme pointeur à
chaque fois que cela est possible.

#include <stdio.h>
int main() {
int N;
int *P = &N;
printf("Saisir un nombre :" );
scanf("%d", P);
if(*P % 2 == 0)
printf("%d est un nombre pair ", *P) ;
else
printf("%d est un nombre impair ", *P) ;
}

64
• ENS de Meknès
Les pointeurs
Exercices
❑ Exercice 6 :
Ecrire un programme qui calcul la somme, le produit, la différence et la division de deux nombres réels.
Utiliser le formalisme pointeur à chaque fois que cela est possible.
#include <stdio.h>
int main(){
float A, B ;
float *P1 ;
float *P2 ;
P1 =&A ;
P2 = &B ;
printf("Entrer la valeur de A :") ;
scanf("%f", P1) ;
printf("Entrer la valeur de B :") ;
scanf("%f", P2) ;
printf("A+B = % .2f\n", *P1 + *P2) ;
printf("A-B = % .2f\n", *P1 - *P2) ;
printf("A*B = % .2f\n", *P1 * *P2) ;
if(*P2!=0)
printf("A/B = %.2f\n ", *P1/ *P2);
else
printf("la division par 0 est impossible") ;
}
65
• ENS de Meknès

Vous aimerez peut-être aussi