UNIVERSITE DU SINE SALOUM

EL-HÂDJ IBRAHIMA NIASS

****************************
UFR Sciences Fondamentales et de
l’Ingénieur
Département Maths, Informatique

ALGORITHME-PROGRAMMATION
LANGAGE C
Licence 1 AGROTIC
2022-2023

Bassirou DIENE
[email protected]

A Introduction à l'algorithmique
A Concepts de base de l'algorithmique
A Les structures de contrôle
A Les types énumérés et les tableaux
A Les sous programmes

1
 q L’algorithmique est une science très
ancienne

q Son nom vient d’un mathématicien arabe

du IXième siècle AL KHAWRISMI

q Des mathématiciens grecs comme

Euclide ou Archimède en ont été les
précurseurs (calcul du PGCD de 2
nombres, calcul du nombre p)

q C’est une notion difficile à préciser

formellement.
2

Diverses définitions sont possibles :

ü Un algorithme est une suite de règles, de raisonnements ou

d'opérations, qui transforment des grandeurs données
(données d'entrée)[angl. input] en d'autres grandeurs
(données de sortie)[angl. output]

ü « Spécification d'un schéma de calcul, sous forme d'une

suite finie d'opérations élémentaires obéissant à un
enchaînement déterminé »

ü « Ensemble de règles opératoires dont l'application permet

de résoudre un problème donné au moyen d'un nombre fini
d'opérations »

3
 q Un nombre fini d’étapes
q Un nombre fini d’opérations par étape
q Fournit un résultat (décidabilité)
q Chaque opération est
ü non ambiguë
ü effective
q Un algorithme doit être indépendant du langage de
programmation utilisé
q Un programme est un algorithme exprimé dans un
langage de programmation capable d’être exécuté
par un ordinateur
4

q Exemple 1: Prise d'un médicament contre la toux

« En cas de toux, prendre, sauf avis contraire du médecin, un
comprimé toutes les 4 heures, jusqu'à disparition des
symptômes. Pour les enfants, un comprimé toutes les 8
heures suffit »

q Exemple 2: Tri d'un jeu de cartes suivant la couleur

(1) Prendre la première carte;
(2) La carte est-elle rouge?
Si oui, poser la carte sur le premier tas;
Sinon, poser la carte sur le second tas;
(3) Reste-t-il des cartes?
Si oui, prendre la carte suivante et continuer sous 2;
Sinon, fin du tri.
5

5
 Spécifications
algorithmiques
Problème
réel
analyse
Traduction
Algorithme
codage
Exécution
Programme

Résultats

Etapes du processus de programmation

q Existence de multiples méthodologies de

développement

qIl y’a généralement un ensemble de points communs:

ü Analyse et définition des besoins : ce que l’on s’attend
que le programme devra réaliser comme tâche.
L’analyse et la spécification du problème se fera dans
un langage naturel
ü Spécification du programme : définir spécifiquement
chaque fonctionnalité du programme.
7

7
 q Conception: décomposition du programme en sous
problème (définition des modules du programme)
ainsi que le développement des algorithmes
nécessaires au fonctionnement du programme. La
conception des algorithmes s’appuiera sur l’analyse
et la spécification du problème

q Programmation: traduction des algorithmes dans le

langage de programmation choisi pour la réalisation
du programme. On parle d’implantation

q Tests et validation: phase durant laquelle le bon

fonctionnement, ainsi que la conformité du programme
aux spécifications sont vérifiés

q Maintenance: activité qui assure l’entretien et le bon

fonctionnement du programme tant et aussi longtemps
qu’il sera utilisé

q Documentation du programme: chaque étape

énoncée doit être documentée pour assurer la pérennité
du programme
9

9
 Soit l'équation mathématique “ ax2 + bx + c = 0 ”.
Écrire un algorithme qui nous fait passer à une
situation finale acceptable si notre situation initiale est
acceptable
q Analyse
q Description des situations initiales acceptables :
• a, b et c sont des valeurs réelles bien définies et
contenus dans des variables de même nom
• delta contient la valeur de l'expression
mathématique “ b*b - 4*a*c ”

10

10

q Description des situations finales acceptables :

ü a, b, c et Delta n'ont pas été modifiées
ü afficher “ Pas de racine réelle” si et seulement si
l'équation ne possède effectivement pas de racine réelle
ü afficher “ Racine double” si et seulement si l'équation
possède effectivement une racine réelle double.
ü afficher “ Deux racines réelles. ” si et seulement si
l'équation possède effectivement deux racines réelles
distinctes.
ü Rien d'autre n‘est affiché ou imprimé depuis la situation
initiale.

11

11
 q Un algorithme peut être spécifié par:

ü un organigramme

ü un pseudo-code

12

12

13
 A Formalisme utilisé en algorithme
A Notion de variable
A Notion de type de données
A Notion d’expression
A Affectation en algorithme
A Entrées/sorties en algorithme

14

14

q Un algorithme doit être lisible et compréhensible par

plusieurs personnes
q Il est composé d'une entête et d'un corps
q l'entête spécifie
ü le nom de l'algorithme (Nom)
ü définition des types annoncée par le mot Type
ü déclaration de constantes annoncée par le mot Constante
ü déclaration des variables, annoncée par le mot Variable
ü définition de sous programmes
q le corps est composé
ü du mot clé début
ü d'une suite d'instructions indentées
ü du mot clé fin
15

15
 ALGORITHME nom de l’algorithme
CONSTANTE
déclaration de constantes
En-tête TYPE
définition de types
VARIABLE
déclaration de variables
DÉFINITION DE SOUS-PROGRAMMES
DÉBUT
Corps instructions du programme
FIN
16

16

Exemple: Ecrire un algorithme qui permet de

faire l’addition de deux nombres entiers.

ALGORITHME addition_2_nombres
VARIABLE
a, b, c: entier
DÉBUT
c ß a+b
FIN
17

17
 q Une variable est une entité qui contient une
information
ü une variable possède un nom appelé
identifiant
ü une variable possède une valeur
ü une variable possède un type qui caractérise
l'ensemble des valeurs que peut prendre la
variable

q L'ensemble des variables sont stockées dans la

mémoire de l'ordinateur
18

18

q Analogie à une armoire d'archive qui contiendrait des

tiroirs étiquetés :
ü l'armoire serait la mémoire de l'ordinateur
ü les tiroirs seraient les variables (l'étiquette
correspondrait à l'identifiant)
ü le contenu d'un tiroir serait la valeur de la variable
correspondante
ü la couleur du tiroir serait le type de la variable
(bleu pour les factures, rouge pour les bons de
commande, etc.)

19

19
 q Le type d'une variable caractérise
ü l'ensemble des valeurs que peut prendre la variable
ü l'ensemble des actions que l'on peut effectuer sur une
variable
q Lorsqu'une variable apparaît dans l'entête d'un
algorithme on lui associe un type en utilisant la syntaxe
suivante:
identifiant_ de_ la_variable : type de données
Exemple :
age : Naturel
nom : Chaîne de Caractères
20

20

q Une fois qu'un type de données est associé à une

variable, cette variable ne peut plus en changer
q Une fois qu'un type de données est associé à une
variable le contenu de cette variable doit
obligatoirement être du même type
q Dans l'exemple précédent on a déclaré a et b comme
des entiers
ü a et b dans cet algorithme ne pourront pas stocker des
réels
ü a et b dans cet algorithme ne pourront pas changer de
type

21

21
 q Il y a deux grandes catégories de type:

ü types de données simples

ü types de données complexes

22

22

q Deux grandes catégories de type simple:

ü Ceux dont le nombre d'éléments est fini,

les dénombrables
ü Ceux dont le nombre d'éléments est infini,
les indénombrables

23

23
 q BOOLÉEN, les variables ne peuvent prendre que les valeurs
VRAI ou FAUX
q INTERVALLE, les variables ne peuvent prendre que les valeurs
entières définies dans cet intervalle, par exemple 1..10
q ÉNUMÉRÉ, les variables ne peuvent prendre que les valeurs
explicitées, par exemple les jours de la semaine (du lundi au
dimanche)
üCe sont les seuls types simples qui peuvent être définis par
l'informaticien
q CARACTÈRES
Exemples
Ø masculin : booléen
Ø mois : 1..12
Ø jour : JoursDeLaSemaine
24

24

q ENTIER (positifs et négatifs)

q NATUREL (entiers positifs)
q RÉEL
q CHAÎNE DE CARACTÈRES, par exemple 'cours'
ou 'algorithmique’

Exemples:
üage : naturel
ü taille : réel
ü nom : chaîne de caractères
25

25
 q Un opérateur est un symbole d'opération qui permet
d'agir sur des variables ou de faire des calculs

q Une opérande est une entité (variable, constante ou

expression) utilisée par un opérateur

q Une expression est une combinaison d'opérateur(s)

et d'opérande(s), elle est évaluée durant l'exécution
de l'algorithme, et possède une valeur (son
interprétation) et un type

26

26

q Exemple dans a+b :

ü a est l'opérande gauche
ü + est l'opérateur
ü b est l'opérande droite
ü a+b est appelé une expression
ü Si par exemple a vaut 2 et b 3, l'expression a+b
vaut 5
ü Si par exemple a et b sont des entiers,
l'expression a+b est un entier

27

27
 q Un opérateur peut être unaire ou binaire :
ü Unaire s'il n'admet qu'une seule opérande, par exemple
l'opérateur non
ü Binaire s'il admet deux opérandes, par exemple l'opérateur +
q Un opérateur est associé à un type de donnée et ne peut
être utilisé qu'avec des variables, des constantes, ou des
expressions de ce type
ü Par exemple l'opérateur + ne peut être utilisé qu'avec les types arithmétiques
(naturel, entier et réel) ou (exclusif) le type chaîne de caractères
ü Impossible d’additionner un entier et un caractère
ü Toutefois exceptionnellement dans certains cas on accepte d'utiliser un
opérateur avec deux opérandes de types différents, c'est par exemple le cas
avec les types arithmétiques (2+3.5)

28

28

q La signification d'un opérateur peut changer

en fonction du type des opérandes

ü Par exemple l'opérateur + avec des entiers aura

pour sens l'addition, mais avec des chaînes de
caractères aura pour sens la concaténation

ü 2+3 vaut 5
ü"bonjour" + " tout le monde" vaut "bonjour tout le monde"

29

29
 q Pour
les booléens nous avons les opérateurs NON,
ET, OU, OU EXCLUSIF

ü NON

ü ET

30

30

ü OU

ü OU EXCLUSIF

31

31
 q On retrouve +, -, /, *
q div : calcul d’une division entière
q modulo : calcul le reste d’une division
entière

Exemple:
ü11 div 2 vaut 5
ü11 modulo 2 vaut 1

32

32

q Opérateur d'égalité
ü C'est l'opérateur que l'on retrouve chez tous les types
simples qui permet de savoir si les deux opérandes
sont égales
ü Cet opérateur est représenté par le caractère =
ü Une expression contenant cet opérateur est un
booléen
q Opérateur d'inégalité !=
q Pour les types possédant un ordre les
opérateurs de comparaison <, >, <=, >=

33

33
 q Tout comme en arithmétique les opérateurs
ont des priorités
ü* et / sont prioritaires sur + et –

q Pour les booléens, la priorité des opérateurs

est non, et, ou Exclusif et ou

q Pour clarifier les choses (ou pour dans

certains cas supprimer toutes ambigüités) on
peut utiliser des parenthèses
34

34

q On ne peut faire que deux choses avec une

variable :
1. Obtenir son contenu (regarder le contenu du
tiroir)
üCela s'effectue simplement en nommant la variable
2. Affecter un (nouveau) contenu (mettre une
(nouvelle) information dans le tiroir)
üCela s'effectue en utilisant l'opérateur d'affectation représenté
par le symbole ß
üLa syntaxe de l’affectation est :
identifiant_variable ß expression sans operateur d'affectation
35

35
 q L'expression c ß a + b se décompose de la
façon suivante:
ü la valeur contenue dans la variable a est
prise
ü la valeur contenue dans la variable b est
prise
ü On additionne ces deux valeurs
ü On met ce résultat dans la variable c
ü Si c avait auparavant une valeur, cette
dernière est perdue

36

36

q Un algorithme peut avoir des interactions avec l'utilisateur

q Il peut afficher un résultat (du texte ou le contenu d'une variable)
et demander à l'utilisateur de saisir une information afin de la
stocker dans une variable
q En tant qu'informaticien on raisonne en se mettant à la place de la
machine:
ü Pour afficher une information on utilise la commande afficher( ) suivie
entre parenthèses de la chaîne de caractères entre guillemets et/ou des
variables de type simple à afficher séparées par des virgules
afficher("Le valeur de la variable a est", a)
ü Pour donner la possibilité à l'utilisateur de saisir une information on utilise
la commande saisir( ) suivie entre parenthèses de la variable de type
simple qui va recevoir la valeur saisie par l'utilisateur, par exemple :
saisir(b)
37

37
 Écrire un algorithme appelé echange qui permet
d’échanger les valeurs de deux variables entières
saisies au clavier.

38

38

Algorithme echange
/* Déclarations */
variable
x , y : entier
tmp : entier
/* Corps du programme */
Début
afficher("Donner la valeur de l'entier x:")
saisir(x)
afficher("Donner la valeur de l'entier y:")
saisir(y)
afficher("Avant échange: x vaut ",x, "et y vaut ",y)
tmp ß x
xßy
y ß tmp
afficher("Après échange: x vaut ",x, "et y vaut ",y)
Fin
39

39
40

/*
Mon premier programme C
*/
#include<stdio.h>

int main(void)
{
printf("Bonjour tout le monde\n");
return 0;
}

41

41
 q Cette directive permet l'inclusion de librairies dont
les éléments seront utilisés dans le programme source
q Le compilateur C fournit un ensemble de librairies
mais le programmeur peut aussi créer ses propres
librairies
q Syntaxe

#include <fichier> ou #include "fichier"

q Exemples :
#include <stdio.h>
#include "C:\MesProgrammes\definitions.h"
42

42

q Elle permet de remplacer dans le programme toutes les

occurrences d’une suite de caractères par un nom de
substitution

q Syntaxe de cette directive :

#define nom_de_substitution suite_de_caractères
Ønom_de_substitution sera utilisé tout au long du programme source pour
représenter la suite de caractères suite_de_caractères.
q Exemple:
#define VRAI 1

q Le mot VRAI sera utilisé pour représenter le chiffre 1 dans le

programme source. Mais rien n’empêche d'utiliser le chiffre 1
43

43
 q Enlangage C, chaque variable doit être associée à un
type, qui permet de spécifier la taille de l’espace occupé
en mémoire (nombre d’octets)
type taille Valeurs possibles Format
int 2 ou 4 de -32768 à 32767 %d
de -2147483648 à 2147483647

short 2 de -32768 à 32767 %d

long 4 de -2147483648 à 2147483647 %ld
float 4 %f
double 8 %lf
char 1 de -128 à 127 %c

44

44

q Lescaractères non imprimables possèdent une

représentation conventionnelle utilisant le caractère \
nommé antislash

q Exemples:
ü\n retour chariot avec saut de ligne
ü\r retour chariot sans saut de ligne
ü\t tabulation horizontale
ü\v tabulation verticale

45

45
 q En C, toute variable doit être déclarée avant sa première
utilisation
q La syntaxe de déclaration d’une variable est:

type identificateur;
q Exemple:
int a ;
q Cette instruction permet de réserver un emplacement mémoire
pour le stockage d’un entier (type int) qui sera nommé a dans la
suite du programme.
q Une déclaration peut se faire seule, ou accompagnée d’une
initialisation (première valeur),
int b=3;
46

46

q La syntaxe de déclaration d’une constante est:

const type identificateur = valeur;
q Exemple :
const int MAX=32767;

q Possibilité
d’utiliser la directive de compilation #define
pour définir une constante selon la syntaxe suivante:
#define identificateur valeur
q Dans ce cas, il n’y a pas de réservation d’emplacement
mémoire.
47

47
 q Si par exemple on additionne un int et un float, il y a
une conversion implicite de l'int en float
q Si le résultat est stocké dans un int, il y a aussi une
conversion avec un risque d'altération du résultat
q Une conversion explicite est faite de la façon suivante :
(nouveau_type) variable
q Exemple de conversion :
int a = 3, b = 6; float c;
c = (float) a * (float) b;

48

48

q Ce sont des opérateurs qui ne s’appliquent qu’a un seul

opérande
Pré-incrémentation i=++j j=j+1 ; i=j

Post-incrémentation i=j++ i=j ; j=j+1

Pré-décrémentation i=--j j=j-1 ; i=j

Post-décrémentation i=j-- i=j ; j=j-1

– int i,j,k;
– i=1; j=2 ;
– k= i++ + j ; /* i=2, j=2, k=3 */
– k= i + ++j ; /* i=2, j=3, k=5 */
– k= i++ + ++j ; /* i=3, j=4, k=6 */
49

49
 q + Addition
q - Soustraction

q * Multiplication

q / Division : si les deux opérandes sont de

type entier la division est entière ; Si au moins
l’un des opérandes est réel, la division est
réelle
q % Modulo : le reste de la division entière ;
les deux opérandes doivent être des entiers.
50

50

q Ilest possible de combiner les opérateurs selon

la forme générale suivante :
x op= i équivalent à x = x op i
q On peut alors avoir les formes suivantes : +=, -
=, *=, /=, %=

q Exemple

i += 20; equiv i = i + 20;

i -= 1; equiv i = i--; equiv i=i-1
51

51
 ! NON (Négation)
== Egalité
!= Différence
=, >, >=, <, <= Relations d’ordre
&& ET logique
|| OU Logique

Attention :
q Il ne faut pas confondre et cela arrive très fréquemment, les
opérateurs : Le test d’égalité (= =) avec l’affectation (=).

52

52

q Il
n’y a pas de type BOOLEAN en C
q Le langage C évalue la validité de toute expression
ou comparaison.
q Par convention le résultat de l’évaluation est :
Ø0 si la comparaison est « fausse » ou si l’expression
évaluée est égale a 0
Ø1 si la comparaison est « vraie » ou si l’expression
évaluée est différente de 0
q Attention: L’évaluation renvoie une expression de
type entier qui peut être utilisée ultérieurement dans
des calculs.
53

53
 q Cette instruction permet de donner la valeur de
l’expression de droite à la variable de gauche

q Le langage C utilise le symbole = pour l’affectation

q Pour affecter un caractère, il faut l’entourer

d'apostrophes (sinon le compilateur pourrait le
confondre avec un nom de variable).
q Pour une chaîne, il faut utiliser des guillemets.

54

54

q La fonction printf permet d’afficher des informations à

l’écran
Syntaxe
üprintf ( " chaîne de caractères " , variable1, variable2, … )

q Cette fonction, contenue dans la bibliothèque standard stdio.h,

attend comme premier paramètre la chaîne de caractère à
afficher avec éventuellement la description des formats
d’affichage des variables à afficher

q Exemple
printf ("la valeur de x est %d et celle de y est %d", x, y );
55

55
 q L’instruction scanf permet au programme de lire des
informations saisies au clavier par l’utilisateur
Syntaxe
scanf ( " chaîne de formatage " , &variable1 , &variable2, . . . )
q Cette fonction, également contenue dans la
bibliothèque standard stdio.h, attend comme premier
paramètre la chaîne décrivant les formats de lecture
des variables à lire au clavier. Les paramètres
suivants sont, dans l’ordre, l’adresse des variables
dont on souhaite lire la valeur.
ØExemple : scanf(" %d %d",&x, &y) ;
56

56

q Les fonctions getchar et putchar de la

bibliothèque stdio.h permettent respectivement
au programme de lire au clavier et d’afficher à
l’écran des caractères.
q Il s’agit de fonctions d’entrées-sorties non
formatées
Exemple:
c=getchar();
putchar(c);
57

57
58

AStructure conditionnelle: Si
AStructure alternative: Si…Sinon
AStructure répétitive: Tant que…. Faire

AStrucrure répétitive: Faire… Tant que

AStructure répétitive: Répéter… jusqu’à
AStructure répétitive: Pour…..
AStructure de choix: Selon

59

59
 q Dans la vie, on a souvent besoin de décider du
déroulement des choses en fonction de certaines
conditions
q Par exemple: "s’il pleut, je prends mon parapluie"
(ceci n'a d'ailleurs de sens que si je souhaite sortir!).
q De même, en algorithme, il est possible de décider de
n'exécuter une action que si une condition particulière
est remplie.

q Il existe 2 grands types de branchements conditionnels:

ü structures conditionnelles
ü structures répétitives, encore appelées boucles
60

60

q Elle s’écrit
Si Condition Alors
instructions
Fin si

q Ce qui se traduit par: si la condition est vraie alors

exécuter les instructions
q Que les instructions soient exécutées ou non, le
programme continue normalement son exécution
après l’instruction Fin si.
q Le programme ne revient plus sur le test du Si une
fois la condition testée
q Un Si n’est pas une répétitive

61

61
 q L’intérêt de l’instruction conditionnelle Si est
qu’il n’y a pas d’instruction à exécuter dans le
cas où la condition est fausse

Remarque:
Ø La condition d’un Si peut être multiple
Ø Les instructions conditionnelles peuvent être
imbriquées
Ø Pour faciliter la lecture, n’oubliez pas l’indentation
(décalage) des instructions
62

62

Algorithme afficheResultat
Variable
moyenne: réel
Début
Afficher(" Entrez la moyenne obtenue")
saisir(moyenne)
Si moyenne >= 10 alors
Afficher (" Semestre validé ")
Fin si
Fin

63

63
 q Elle s’écrit: Si Condition alors
Instructions « Alors »
Sinon
Instructions « Sinon »
Fin si

q Ce qui se traduit par: si la condition est vraie alors,

exécuter les instructions du bloc « Alors », sinon les
instructions du bloc « Sinon »
q Que les instructions du bloc Alors ou bloc sinon soient
exécutées ou non, le programme continue normalement
son exécution après l’instruction Fin si.
q Un Si Sinon n’est pas une répétitive

64

64

Algorithme afficheResultat2
Variable
moyenne: réel
Début
Afficher(" Entrez la moyenne obtenue")
saisir(moyenne)
Si moyenne >= 10 alors
Afficher (" Semestre validé ")
Sinon
Afficher (" Semestre non validé ")
Fin si
Fin

65

65
 Algorithme afficheResultat3
Variable
moyenne: réel
Début
Afficher(" Entrez la moyenne obtenue")
saisir(moyenne)
Si moyenne >= 10 alors
Afficher (" Semestre validé ")
Sinon
Si moyenne >= 9,5 alors
Afficher (" Admis au repêchage ")
Sinon
Afficher (" Semestre non validé ")
Fin si
Fin si
Fin
66

66

q Elle s’écrit: Tant que Condition Faire

Instructions
Fin Tant que

q Ce qui se traduit par: Tant que la condition est vraie, exécuter les
instructions.
q Cette fois-ci, il s’agit d’une instruction de répétition, appelée
également une boucle. Le programme va tester avant chaque tour
de boucle si la condition est vraie
q Dans l’affirmative il exécute les instructions jusqu’au Fin Tant
que, puis il revient au test de la condition.
q Lorsque la condition devient fausse, la boucle Tant que Faire se
termine et le programme continue normalement son exécution
après l’instruction qui suit le Fin Tant que.

67

67
 q Saisie d’une valeur positive par l’utilisateur
Algorithme saisirValeurPositif
Variable
val: Entier
Début
Afficher(" Entrez une valeur numérique positive")
saisir(val)
/* Boucler tant que la valeur lue n’est pas correcte */
Tant que val < 0 Faire
Afficher (" Erreur: Entrez une valeur positive ")
saisir(val)
Fin Tant que
Afficher(" la valeur saisie est ", val)
Fin

68

68

Attention
q pour le bon fonctionnement d’une boucle:
Ø Il faut vérifier qu’à un moment on peut entrer dans
la boucle pour y exécuter les instructions, ceci afin
d’éviter les boucles inutiles
Ø Il faut vérifier également qu’à un moment on sort
de cette boucle. Ceci pour éviter les boucles
infinies.

69

69
 q Elle s’écrit:
Faire
instructions
Tant que Condition

q Ce qui se traduit par: Exécuter les instructions

Tant que la condition est vraie
q les instructions sont exécutées une première fois
puis le test de la condition est effectué pour
éventuellement reprendre l’exécution des
instructions
70

70

q Saisie d’une valeur positive par l’utilisateur

Algorithme saisirValeurPositif2
Variable
val: Entier
Début
Faire
Afficher (" Entrez une valeur positive ")
saisir(val)
Tant que val < 0
Afficher(" la valeur saisie est ", val)
Fin

71

71
 q Lorsque la condition devient fausse, la boucle
Faire Tant que se termine et le programme
continue normalement son exécution après
l’instruction Tant que Condition.
q Cette instruction de contrôle évite de devoir
mettre en place une ou plusieurs instructions
préliminaires assurant l’entrée dans la boucle un
jour

72

72

q Elle s’écrit:
Répéter
Instructions
Jusqu’à condition
q Ce qui se traduit par: Exécuter les instructions jusqu’à ce que la
condition soit VRAIE.
q Les instructions sont exécutées une première fois puis le test de la
condition est effectué pour éventuellement reprendre l’exécution
des instructions.
q Lorsque la condition devient vraie, la boucle Répéter jusqu’à se
termine et le programme continue son exécution après
l’instruction Jusqu’à condition.
q C’est le contraire de la boucle faire tant que

73

73
 q Saisie d’une valeur positive par l’utilisateur

Algorithme saisirValeurPositif2
Variable
val: Entier
Début
Répéter
Afficher (" Entrez une valeur positive ")
saisir(val)
jusqu’à val > 0
Afficher(" la valeur saisie est ", val)
Fin

74

74

q La différence entre un Faire Tant que et un Répéter Jusqu’à ne

se situe qu’au niveau de l’écriture de la condition
q
q Dans Faire Tant que la condition doit devenir fausse pour
quitter la boucle

q Dans Répéter Jusqu’à il faut que la condition devienne vraie

pour quitter la boucle
ØLe programme exécute au moins une fois les instructions
avant de faire le test de la condition, puis possibilité
d’exécuter de nouveau un certain nombre de fois les
instructions, jusqu’à ce que la condition devienne vraie

75

75
 q Elle s’écrit:
Pour VariableDeBoucle valDébut à valFin pas de valPas faire
Instructions
Fin Pour
q Ce qui se traduit par: Pour une variable de boucle dont
le contenu varie de valDébut à valFin par pas de valPas
exécuter les instructions.
q L’instruction de contrôle Pour permet d’exécuter les
instructions un nombre déterminé de fois. Ce nombre
est connu avant de commencer à exécuter le Pour.
q La boucle ne s’arrête que lorsque le nombre de
répétition des instructions demandé a été réalisé
76

76

q Dans une instruction Pour, la valeur « Pas

d’incrémentation » est de 1 par défaut.
q Pour mettre en place une boucle Pour décroissante, la
valeur d’initialisation doit être supérieure à la valeur de
fin
q Tandis que dans le cas d’une boucle Pour croissante la
valeur d’initialisation doit être inférieure.
Pour val 1 à 10 faire Pour val 10 à 1 pas de -1 faire
val val*10 val val*4
Fin Pour Fin Pour

77

77
 q Une instruction Pour est en fait une réécriture
simplifiée d’une instruction Tant que
q Il est possible de réécrire une boucle Pour à
l’aide d’une boucle Tant que
Pour i 1 à 10 faire i 1
afficher (i*10) Tant que i <= 10 Faire
Fin Pour afficher ( i*10)
i i+1
Fin Tant que

78

78

q Elle s’écrit:
Selon ExpressionDeTest Faire
cas Expression: Instructions
cas Expression: instructions
cas Expression: Instructions
………………………………….
………………………………….
cas Sinon: Instructions
Fin Selon

q où expression est nécessairement une expression de

type scalaire (entier, caractère, booléen ou énuméré).
79

79
 q La structure Selon permet de choisir le traitement à
effectuer en fonction de la valeur d'une variable ou
d'une expression.
q Cette structure permet parfois de remplacer
avantageusement une structure Si
q L’expression est évaluée, puis sa valeur est
successivement comparée à chacune des valeurs
q Dès qu’il y a correspondance, les comparaisons sont
arrêtées et le traitement associé est exécuté. Si aucune
valeur ne correspond à la valeur de l’expression, alors
le traitement associé au Sinon, s’il existe, est exécuté
80

80

Algorithme afficherJour
Variable
jour:entier
afficher("Donner le numéro du jour")
saisir(jour)
Selon (jour) Faire
1 : afficher("Lundi")
2 : afficher("Mardi")
3 : afficher( "Mercredi")
4 : afficher("Jeudi")
5 : afficher( "Vendredi")
6 : afficher("Samedi")
7 : afficher("Dimanche")
Sinon afficher("Un numéro de jour doit être compris entre 1 et 7")
Fin Selon

81

81
82

if (condition1) {
traitement1;
}
else if (condition2) {
traitement2;
}
else if (conditionN) {
traitementN;
}
else{
traitement;
}

q Les conditions doivent être entre parenthèses

q Si un traitement comporte une seule instruction
les accolades peuvent être omises
83

83
 #include <stdio.h>
int main() {
int val1,val2, res;
printf(" Donnez une valeur");
scanf("%d ",&val1);
printf("Donnez une autre valeur");
scanf("%d",&val2);
if(val1<val2) {
res=val2-val1;
else
res=val1-val2;
}
printf("la différence est de %d ",res);
return 0;
}

84

84

while (condition) {
traitement;
}

q Les conditions doivent être entre parenthèses.

q Si un traitement comporte une seule
instruction les accolades peuvent être omises

85

85
 q Elle s’écrit:
do {
traitement;
} while (Condition);
q Les conditions doivent être entre parenthèses
q L’instruction du while se termine par un point
virgule (;)

86

86

q Elle s’écrit
for(instruction1;condition;instruction2)
{
traitement;
}
q Le déroulement se fait ainsi:
Øinstruction1 est exécutée une seule fois
ØPuis il y a l'enchaînement suivant:
ü La condition est évaluée
ü Si elle est fausse, on sort de la boucle.
ü Si elle est vraie, le traitement de la boucle est exécuté, puis
instruction2 est exécutée et on recommence en évaluant à nouveau la
condition, etc …
87

87
 q En général
Ø instruction1 permet d'initialiser une variable compteur
Ø instruction2 permet d'incrémenter ou de décrémenter une
variable compteur
q Exemple

for(x = 0; x <= 20; x ++)

{
printf("%d", x);
}

q A la sortie de la boucle, x vaut 21.

88

88

switch (expression)
{ …
case valeur1 : traitement1; printf("Donner le numéro du jour")
break; scanf("%d", &jour)
case valeur2 : traitement1; switch (jour)
break; {
... case 1 : printf(“Lundi"); break;
case valeurN : traitementN; case 2 : printf(“Mardi"); break;
break; ...
default : traitement; case 7 : printf("Dimanche"); break;
} default : printf("Un numéro de jour doit
être compris entre 1 et 7"); break;
}
...

89

89
 q L'instruction break peut être employée à
l'intérieur de n'importe quelle boucle. Elle
permet d'interrompre le déroulement de la
boucle, et passe à la première instruction qui
suit la boucle. En cas de boucles imbriquées,
break fait sortir de la boucle la plus interne.

90

90

q L'instruction continue permet de passer

directement à l'étape suivante d'une
boucle sans exécuter les autres
instructions de la boucle qui la suivent.

91

91
 LES TABLEAUX

92

LES TABLEAUX
q Un tableau est un outil qui permet de regrouper
sous le même nom un ensemble de variables de
même type
q On appelle tableau une variable composée de
données de même type, stockée de manière
contiguë en mémoire (les unes à la suite des autres)
q Un tableau est donc une suite de cases (espace
mémoire) de même taille.
q La taille de chacune des cases est conditionnée par
le type de donnée que le tableau contient
93

93
 TABLEAUX UNIDIMENSIONNELS

q Un tableau à une dimension peut être vu comme une

liste d'éléments
q On le représente souvent comme une suite de cases
contenant chacune une valeur
q Exemple: Tableau notes
15 13 9 17 5 10
ère ème
1 case 4 case

q Un tableau possède un nom (ici notes) et un nombre

d'éléments (de cases) qui représente sa taille (ici 6).

94

94

DÉCLARATION TABLEAU UNIDIMENSIONNEL

q Pour déclarer un tableau dont les éléments ont

un type de base :
ü partir de la déclaration de variable ayant un type de
base ;
ü ajouter entre crochets le nombre d'éléments du
tableau après le nom
q En algorithme, la syntaxe de la définition d'un
tableau unidimensionnel est la suivante
nom_tableau: tableau [N] de type

95

95
 DÉCLARATION TABLEAU UNIDIMENSIONNEL

q type définit le type d'élément que contient le tableau,

c'est-à-dire qu'il définit la taille d'une case du tableau en
mémoire
q nom_tableau est le nom donné au tableau, le nom du
tableau suit les mêmes règles qu'un nom de variable
q N est un nombre entier qui détermine le nombre de cases
que le tableau doit comporter
Exemple
variable
• salaires : tableau[6] de réel
• étudiants: tableau [25] de chaîne
• notes : tableau[8] d’entier
96

96

ACCÉS AUX ÉLÉMENTS D’UN TABLEAU

q Pour accéder à un élément du tableau, le nom

donné à celui-ci ne suffit pas car il comporte
plusieurs éléments
q Un nombre appelé indice est défini qui,
combiné avec le nom du tableau, permet de
décrire exactement chaque élément
q Pour accéder à un élément du tableau, il suffit
donc de donner le nom du tableau, suivi de
l'indice de l'élément entre crochets
nom_du_tableau[indice]
97

97
 ACCÉS AUX ÉLÉMENTS D’UN TABLEAU
q Un élément particulier du tableau est désigné en
précisant son indice (son numéro)
q Le premier élément du tableau correspond à l’indice 0
et est désigné par nom_tableau[0]
q Le deuxième élément du tableau correspond à l’indice
1 et est désigné par nom_tableau[1]
q Le dernier élément du tableau correspond à l’indice N-
1 et est désigné nom_tableau[N-1]
q Quelque soit sa forme, la valeur de l'indice doit être
entière et comprise entre les valeurs minimale et
maximale déterminées à la déclaration du tableau
98

98

MANIPULATION TABLEAU
UNIDIMENSIONNEL
q Les éléments d'un tableau sont des variables appelées
variables indicées qui s'utilisent exactement comme
n'importe quelle autre variable classique
ü Elles peuvent faire l'objet d'une affectation

ü Elles peuvent figurer dans une expression arithmétique,

dans une comparaison
ü Elles peuvent être affichées et saisies…

q On ne peut pas manipuler un tableau de manière globale(

affectation à un autre tableau, affichage, saisie…).
q Il faut le manipuler élément par élément (en le parcourant
avec une boucle Pour par exemple)

99

99
 EXEMPLE
Algorithme saisiAfficheTab
i,n:entier
tab: tableau[20] d’entier
debut
faire
afficher("Donner le nombre d'elements du tableau ")
saisir(n)
tant que ((n<0)||(n>20))
//Saisi des élements du tableau
pour i 0 à n-1 faire
afficher("Donner l'element” ,i+1, “du tableau")
saisir(tab[i])
fin pour
//Affichage des éléments du tableau
pour i 0 à n-1 faire
afficher(tab[i],’’ ‘’)
fin pour
fin
100

100

LES TABLEAUX EN C
q En C, la syntaxe de la déclaration d'une variable tableau est la
suivante:
type nom_tableau [ N ];
ü nom_tableau est l’identificateur du tableau
ü N est la taille du tableau et doit être une constante entière et
positive.

q Exemple :
ü int tab[10] ; //déclare une variable tableau de 10 entiers appelée tab.
ü tab[0] désigne le premier élément du tableau tab
ü tab[9] désigne le dernier élément du tableau tab

101

101
 EXEMPLE
#include <stdio.h>
#include <stdlib.h>
int i,n;
int tab[20];
int main(void) {
do {
printf("Donner le nombre d'elements du tableau \n");
scanf("%d",&n);
}while((n<0)||(n>20));
//Saisi des élements du tableau
for(i=0;i<n;i++){
printf("Donner l'element %d du tableau \n",i+1);
scanf("%d", &tab[i]); }
//Affichage des éléments du tableau
for(i=0;i<n;i++){
printf("%7d" ,tab[i]); }
return 0;
}
102

102

INITIALISATION D'UN TABLEAU

q Il est possible d'initialiser un tableau avec une liste d'expressions
constantes séparées par des virgules, et entourée des signes { et
}.
q Exemple :
#define N 5
int t[N] = {1, 2, 3, 4, 5};
q Possibilité de donner moins d'expressions constantes que le
tableau ne comporte d'éléments.
ü Dans ce cas, les premiers éléments du tableau seront
initialisés avec les valeurs indiquées, les autres seront
initialisés à zéro.
#define N 10
int t[N] = {1, 2};
103

103
 CAS DES TABLEAUX DE CARACTÈRES
q Un tableau de caractères peut être initialisé par une liste
de constantes caractères.
ü Exemple : char ch[3] = {'a', 'b', 'c'}; C'est évidemment une
méthode très lourde.
q Un tableau de caractères peut être initialisé par une chaîne
littérale
ü char ch[8] = "exemple";
q Le compilateur complète toute chaîne littérale avec un
caractère null
q Il faut donc que le tableau ait au moins un élément de plus
que le nombre de caractères de la chaîne littérale

104

104

CAS DES TABLEAUX DE CARACTÈRES

q Il est admissible que la taille déclarée pour le tableau
soit supérieure à la taille de la chaîne littérale
ü char ch[100] = "exemple"; dans ce cas, seuls les 8
premiers caractères de ch seront initialisés.
q Il est également possible de ne pas indiquer la taille du
tableau
ü Dans ce cas, le compilateur compte le nombre de caractères
de la chaîne littérale et donne la taille adéquate au tableau
(sans oublier le null)
Ø char ch[] = "ch aura 22 caractères";

105

105
 FONCTIONS DE MANIPULATION DE
CHAÎNES
q La bibliothèque standard string.h fournit des fonctions de
manipulations des chaînes de caractères
q Après la déclaration, l’affectation d’une chaîne se fera par la fonction
STRCPY
ü Exemple : strcpy(ch, ''hello'') ;
q La longueur (le nombre de caractères) d’une chaîne est donnée par la
fonction STRLEN
q Cette fonction ne prend pas en compte le caractère \0.
ü Exemple : strlen(''bonjour'') retourne 7.
q La concaténation de deux chaînes se fait par la fonction STRCAT
ü Exemple : strcat(ch, '' world'') ; la chaîne contient alors
''hello world''
106

106

FONCTIONS DE MANIPULATION DE
CHAÎNES
q La comparaison de deux chaînes se fait par la
fonction STRCMP.
ü Exemple : n = strcmp(ch1, ch2) ;
n vaudra :
ü un nombre négatif si ch1 < ch2 au sens syntaxique
ü 0 si ch1 et ch2 sont identiques
ü un nombre positif si ch1 > ch2

107

107
 TABLEAUX MULTIDIMENSIONNELS

q Les tableaux multidimensionnels sont des tableaux

qui contiennent des tableaux.
q Par exemple le tableau bidimensionnel (3 lignes, 4
colonnes) suivant, est en fait un tableau comportant
3 éléments, chacun d'entre eux étant un tableau de 4
éléments :

a b c d

e f g h

i j k l

108

108

LES TABLEAUX EN C
q En C, la syntaxe de la déclaration d'une variable tableau est la
suivante:
type nom_tableau [N][M];
ü nom_tableau est l’identificateur du tableau
ü N est le nombre de lignes du tableau et doit être une constante
entière et positive.
ü M est le nombre de colonnes du tableau et doit être une constante
entière et positive.
q Exemple :
ü int tab[3] [4] ; //déclare une matrice de 3 lignes et 4 colonnes appelée tab.
ü tab[0] [0] désigne la première case de la matrice tab
ü tab[1] [1] désigne le cinqième case de la matrice tab

109

109
 TABLEAUX MULTIDIMENSIONNELS
q L’accèsà un élément se fait en précisant un
indice entre crochets pour chaque
dimension

q Pour parcourir tous les éléments d’un

tableau à deux dimensions, on peut
utiliser deux boucles Pour imbriquées : la
première boucle pour une dimension et la
deuxième pour l’autre dimension.
110

110

EXEMPLE
#include <stdio.h> printf("*** Matrice B ***\n");
main() for (i=0; i<n; i++)
{ int A[50][50]; /* matrice dénommée A */ for (j=0; j<m; j++){
int B[50][50]; /* matrice dénommée B */ printf("Element[%d][%d] : ",i,j);
int n, m; /* dimensions des matrices scanf("%d", &B[i][j]);
*/ }
int i, j; /* variables de boucles */ /* Affichage des matrices */
/* Saisie des donnÈes */ printf("Matrice A :\n");
printf("Nombre de lignes (max.50) : "); for (i=0; i<n; i++) {
scanf("%d", &n ); for (j=0; j<m; j++)
printf("Nombre de colonnes (max.50) : printf("%7d", A[i][j]);
"); printf("\n");
scanf("%d", &m); }
printf("*** Matrice A ***\n"); printf("Matrice B :\n");
for (i=0; i<n; i++) for (i=0; i<n; i++){
for (j=0; j<m; j++) for (j=0; j<m; j++)
{
printf("%7d", B[i][j]);
printf("Element[%d][%d] : ",i,j); printf("\n");
scanf("%d", &A[i][j]);
}
} }
111

111
 LES ENUMERATIONS

112

LES ÉNUMÉRATIONS
q Une énumération est un type de données dont les valeurs
sont des constantes nommées
q Elles permettant de définir un ensemble de constantes,
parmi lesquelles les variables de ce type prendront leur
valeur
q La syntaxe de définition d’un type énuméré est la
suivante :
TYPE
nom_type = { constante1, constante2, …, constanteN }
ü nom_type est l’identificateur du nouveau type
ü et constante1, constante2, …, constanteN est une liste
d’identificateurs donnant l’ensemble des valeurs de ce type
11
3

113
 LES ÉNUMÉRATIONS

q Exemple:
TYPE
// définition du type couleur
couleur = {bleu, blanc, rouge, vert, jaune, noir}
// définition du type jour
jour = {lundi, mardi, mercredi, jeudi, vendredi, samedi,
dimanche}

11
4

114

DÉCLARATION D’UNE VARIABLE DE

TYPE ÉNUMÉRÉ
q Après avoir défini un type énuméré, on peut l'utiliser
comme un type normal pour déclarer une ou plusieurs
variables de ce type
Exemple :
…
variable
c : couleur // déclaration de la variable c de type couleur
Début
…
c = bleu // utilisation de la variable c
…
Fin
11
5

115
 EXEMPLE
Algorithme jourEnumeration
Type
jour={Lundi=1,Mardi,Mercredi,Jeudi,Vendredi,Samedi,Dimanche}
Variable
un_jour: jour
Début
afficher("Donnez un numéro de jour entre 1 et 7")
saisir(un_jour)
selon(un_jour ) faire
Lundi : afficher("C’est Lundi")
Mardi : afficher("C’est Mardi")
Mercredi : afficher("C’est Mercredi")
sinon : afficher("Ce n’est ni Lundi ni Mardi ni Mercredi")
fin selon
fin

11
6

116

LES ÉNUMÉRATIONS EN C
q En C, on définit un type énuméré en utilisant le
mot-clé enum selon la syntaxe suivante :
ENUM nom_énumération { nom1, nom2 ... };

q Exemple

ü enum JourDeSemaine { LUNDI, MARDI,

MERCREDI, JEUDI, VENDREDI, SAMEDI,
DIMANCHE };
ü enum couleur {bleu, blanc, rouge, vert, jaune, noir} ;
11
7

117
 LES ÉNUMÉRATIONS EN C
q Chaque constante est associée à un entier (son numéro d’ordre
en partant de 0 pour le premier)
q Possibilité aussi de spécifier la valeur associée

Exemple:
enum jour
{Lundi=1,Mardi,Mercredi=5,Jeudi,Vendredi,Samedi,Dimanche};
üMardi prend la valeur 2, Jeudi la valeur 6,…
ü Les valeurs associées aux constantes ne sont pas
modifiables dans le programme.
q Après avoir défini un type énuméré, on peut l'utiliser pour
déclarer une ou plusieurs variables de ce type
ü enum jour j1;
ü enum jour j2 = Mardi;
11
8

118

EXEMPLE
#include <stdio.h>
#include <conio.h>
enum jour
{Lundi=1,Mardi,Mercredi,Jeudi,Vendredi,Samedi,Dimanche};
void main() {
enum jour un_jour;
printf("Donnez un numéro de jour entre 1 et 7") ;
scanf("%d", &un_jour) ;
switch(un_jour ) {
case Lundi : printf("C’est Lundi"); break ;
case Mardi : printf("C’est Mardi"); break ;
case Mercredi : printf("C’est Mercredi"); break ;
default : printf("Ce n’est ni Lundi ni Mardi ni Mercredi");
}
getch();
}
11
9

119
120

q La structure de tableau permet de traiter un nombre fini

d’informations de même type auxquelles on peut accéder
par un indice
q Il est nécessaire d’organiser de façon hiérarchique un
ensemble de données de types différents mais qualifiant un
même objet
ü les dates chronologiques (année, mois, jour),
ü les fiches bibliographiques (titre du livre, auteur, date de
parution)
ü les fiches personnelles (nom, prénom, âge, sexe, taille)
q La nature différente de ces éléments (données) conduit le
programmeur à utiliser une structure permettant la définition
explicite de chacun de ces éléments : enregistrement

121

121
 q Un enregistrement est un type structuré formé
d’un ou de plusieurs éléments pouvant être de
types différents
q Chaque enregistrement est désigné par un
identificateur (son nom)
q Chacun des éléments de l’enregistrement
occupe un emplacement appelé champ
désigné à son tour par un identificateur et
caractérisé par un type
q Une information représente la valeur du
champ
122

122

123

123
 q Définition d’un type d’enregistrement
TYPE
identifiant_enr = ENREGISTREMENT
Champ1 : type de données
Champ2 : type de données
…
Champn : type de données
FIN

q Déclaration variable de type enregistrement

Variable
identifiant_variable : identifiant_enr
124

124

Exemple:
TYPE
etudiant= ENREGISTREMENT
nom: chaine de caractères
prenoms: chaine de caractères
dateNaiss : chaine de caractères
adresse : chaine de caractères
numeroCarte : entier
FIN

Exemple de déclaration variable

Variable
etud: etudiant

125

125
 Remarque :

1. La définition d’un type enregistrement

ne crée pas une variable enregistrement
2. Pour créer une variable enregistrement,
il faut procéder à sa déclaration dans la
section variable

126

126

q Possibilité de déclarer une variable enregistrement

sans définition préalable d’un type enregistrement
Variable
variable_enr : enregistrement
champ1 : type de données
champ2 : type de données
…
champn : type de données
fin

127

127
 Exemple:
Variable
voiture : ENREGISTREMENT
marque : chaine
date_fabrication : chaine
immat :chaine
nbreplace : entier
fin

q Cette déclaration crée une variable enregistrement

voiture composée de quatre champs

128

128

q Accés aux champs d’un enregistrement: nom composé

ü L’accès à un champ se fait donc en nommant

la variable enregistrement puis le champ et
séparant les deux noms par un point «. »
idetifiant_variable.champi

identifiant_variable est l’identificateur de la variable

enregistrement et champi est l’identificateur du champ

129

129
 q Accés aux champs d’un enregistrement: nom composé
afficher("Donner le numéro de carte :")
saisir(etud.numeroCarte)
afficher("Donner le nom :")
saisir(etud.nom)
afficher("Donner le prénoms :")
saisir(etud.prenoms)
afficher("Date de naissance:" )
saisir(etud.dateNaiss)
afficher("Adresse :")
saisir(etud.adresse) 130

130

LES STRUCTURES EN LANGAGE C

q En C, un type structure est défini en utilisant le mot-

clé struct selon la syntaxe suivante :

struct nom_enregistrement{
Type1 nom_champ1;
...
TypeN nom_champN;
};
ü nom_enregistrement est l’identificateur du nouveau type
ü type1, …, typeN sont les types respectifs des champs champ1,
…, champN
131

131
 DÉCLARATION D’UN TYPE STRUCTURE

struct date{
int jour;
char mois[10];
int annee;
};

struct complexe
{
float reelle;
float imaginaire;
};

132

132

OPÉRATIONS SUR LES STRUCTURES

q L’accès aux différents champs d'une structure se fait
grâce à l'opérateur point, noté ''.''.
q Par exemple, le champ appelé champ1 d’une variable
structure x est désigné par l'expression x.champ1
q Il est possible d’effectuer sur le champ d'une structure
toutes les opérations valides sur des variables de
même type que ce champ
q Il est possible d’appliquer l'opérateur d'affectation à
une structure (à la différence d’un tableau)
q Cela permet de copier tous les champs de la structure

133

133
 EXEMPLE

VARIABLES

struct date d; // d est une variable de type date

struct complexe c1,c2; //déclaration de deux variables de type

struct complexe de noms c1 et c2;

c1.réelle=4; c1.imaginaire=90; //affectation de valeurs

d.jour=23; d.mois=”Mars”; d.annee=1992;

134

134

EXEMPLE
#include <stdio.h>
#include <stdlib.h>
struct complexe{
float reel;
float ima;
};

main(){
struct complexe c1, c2;
printf("Donnez la partie réelle puis la partie imaginaire du premier complexe\n");
scanf("%f%f",&(c1.reel),&(c1.ima));
printf("Donnez la partie réelle puis la partie imaginaire du second complexe\n");
scanf("%f%f",&(c2.reel),&(c2.ima));
printf("La somme de C1 = %f + i%f et C2 = %f + i%f est le complexe Z1 = %f +
i%f\n", c1.reel,c1.ima,c2.reel,c2.ima,(c1.reel+c2.reel),(c1.ima+c2.ima));
}

135

135