cours3

Rappel: instructions conditionnelles
2 structures conditionnelles principales:
Le si -- sinon si -- sinon:
if (expression){
instructions;
} else if (expression){
instructions;
} else {
instructions;
}
Le switch
switch (expression){
case val1:
instructions;
break;
case val2:
instructions;
break;
…
default:
instructions;
}
Etapes a suivre pour
développer un programme
-1-traduction du problème
-> Représentation mathématique
-2-Identification des variables et des types
-3-Décomposition en tâches simples
-> Structure générale + fonctions
-> écriture du pseudo-code (algo)
-4-Transposition dans le langage C
Algorithme -> pseudo-code -> C
Racines d’un polynôme
du second ordre
P(x)=a.x2+b.x+c
Δ=b2-4.a.c
Δ=0 →x0=-b/2a
Δ>0 →x1,2=(-b±√∆)/2a
Lire réels a,b,c
delta=b*b-4*a*c
Si (delta==0){
x=-b/2./a;
} sinon si (delta>0){
x1=(-b+sqrt(delta))/2./a;
x2=(-b=sqrt(delta))/2./a;
} sinon{
pas de solution;
}
#include <stdio.h>
int main(){
float a,b,c
scanf(“%f %f %f”,&a,&b,&c);
float delta=b*b-4.*a*c;
if (abs(delta)<1.e-5){
float x=-b/2./a;
printf(“un racine reelle: %f”,x);
} else if (delta>0){
float x1=(-b+sqrt(delta))/2./a;
float x2=(-b-sqrt(delta))/2./a;
printf(“deux racines reelles %f %f”,x1,x2);
} else {
printf(“pas de racine reelle”);
}
return 0;
}
Les boucles: tant que (while)
Structure du tant que en langage
algorithmique:
tant que (expression) est vrai, la
boucle continue.
while (expression)
{
block d’instructions;
}
expression retourne une valeur
logique vrai/faux
Ex: incrémenter x tant que x est
plus petit que la valeur 10.
Sort de la boucle quand x==10
est vrai
int x=0;
while(x<10){
x++;
}
Les boucles: pour (for)
init cond. repet. compteur
La boucle for est une
structure principalement de
comptage mais est
néanmoins plus générale.
for (<expr1>;<expr2>;<expr3>)
{
block d’instructions;
}
Ex: exécute une instruction
20 fois.
int I;
for (I=0;I<20;I++){
instruction;
}
for est plus général car
<expr2> n’agit pas
nécessairement sur la même
variable que <expr1>. Ex:
int x,y;
for (x=1;y>30;x++){
y=rand();
}
Les boucles: faire tant que (do
while)
do - while est similaire au while a la
différence prêt que le while évalue la
condition avant le block d’instructions
tandis que le do-while le fait après.
do{
block d’instructions;
} while (<expr>);
Cette structure est moins fréquente que le while mais
apporte parfois une solution plus élégante au niveau de
l’algorithme. Ex:
float N;
do {
printf(“introduisez un nombre entre 1 et 10:”);
scanf(“%f”,&N);
} while (N<1 || N >10);
Comment choisir la boucle
adaptée
Si le block d’instructions doit être exécute au moins 1 fois :
do-while
Si vous connaissez au préalable le nombre d’itérations:
for
Si le block d’instruction ne doit pas être exécuté si la condition
est fausse:
while ou for
for a le désavantage de favoriser la prog. de structures
surchargées
while a le désavantage de mener à de longues structures où
les conditions de répétitions sont noyées.
Les fonctions
Utiliser une fonction se fait en deux temps en C:
1-déclaration 2- définition
déclaration: avant le main (global) ou dans le main ou une
fonction (locale)
<TypeRes> <NomFonc> (<TypePar1> [<NomPar1>],
<TypePar2> [<NomPar2>],…);
définition: après le main
<TypeRes> <NomFonc> (<TypePar1> [<NomPar1>],
<TypePar2> [<NomPar2>],…)
{
<déclarations locales>;
<instructions>;
return;
}
Les fonctions
#include <stdio.h>
Commandes préprocesseur (#)
float aplusb(float a, float b);
Déclaration des fonctions
Programme principal
int main ()
{
float a,b,c;
Déclaration des variables
a=1.5;
b=3.1; c=0.;
Initialisation des variables
c=aplusb(a,b);
printf(“a+b=%f”,c);
Appel des modules/fonctions
return 0;
}
float aplusb(float a,float b)
{
return a+b;
}
Définition des fonctions/modules
Les fonctions recursives
Les fonctions récursives sont des
fonctions qui s’appellent elles-même.
La déclaration est identique a une
déclaration de fonction standard.
Pour définir une fonction récursive il faut
1- une condition de récurence
int ajout(int x,int N){
2- une condition d’arrêt
if (N==0){
return x;
exemple:
} else {
ajouter N fois 1 à un entier
return 1+ajout(x,N-1);
}
}
Portée des variables
Les variables définies dans un bloc ({…}) sont disponibles
dans le bloc.
Re-déclarer dans un bloc une variable supprime toute
utilisation de la première variable dans le bloc
Ex:
int X=199,i;
if (X>0){
float X;
for (i=0;i<10;i++){
X=i+1.5;
printf(“%f\n”,X);
}
}
printf(“%d\n”,X);
dans cette partie X sera une
variable de type float
Exercices:
Ex 6: factorielle
On désire calculer la factorielle d’un nombre entier. Donner
l’algorithme itératif qui permet de le faire et transcrivez le en C.
Donner ensuite l’algorithme récursif permettant de calculer la
factorielle et transposer le en C.
Exercices:
Ex 7: devinette
Que fait le programme
ci-contre?
Ecrivez un programme
qui permet de faire la
même chose mais en
utilisant une variable
intermédiaire.
Int main()
{
int a,b;
printf(“Veuillez entrer 2 entiers\n”);
scanf(“%d %d”,&a,&b);
b=a+b;
a=b-a;
b=b-a;
printf(“a=%d b=%d\n”,a,b);
return 0;
}