Indications pour ceux qui veulent lire vite...
Les titres principaux des parties sont centrés en gras et soulignés. Les sous-parties sont alignées dans la gauche, en gras-italique et marron. Les récapitulatifs sont en bleu. Les codes C++ sont écrit en type "codé" et gras.
I. Application pratique et approfondissement
1.1 Cahier des charges
1.2 La stricte base
1.3 Le menu
1.4 Gestion du menu
1.5 Calculer les racines de polynômes du second degré
1.6 Opérations sur les triangles
1.7 Amélioration du menu
II. Autres opérateurs
2.1 Compléments aux opérations
mathématiques
2.2 Plus loin dans les associativités de condition
I. Application pratique et approfondissement >>
vers le sommaire
1.1 Cahier des charges >> vers le sommaire
Nous avons vu des commandes spécifiques du code de façon
assez indépendante la plupart du temps. Maintenant, nous allons nous
donner un but et exploiter tous les outils que nous connaissons, ainsi que
quelques autres nouveaux, pour le mener à bien. Voici ce qu'il va vous
falloir réaliser :
- Le programme doit permettre de calculer les racines d'un polynôme
du second degré.
- Il doit être capable de détecter si des triangles sont rectangles
et, dans ce cas là, dire en quel point.
- Sa présentation doit être compréhensible, claire et
efficace.
A la lecture de cette demande, vous devez imaginer ce que vous
allez créer. Il n'est pas nécessaire pour un si petit programme
de commencer sur papier à dessiner une arborescence, mais il est vital
que vous sachiez ce que vous voulez avant de taper sur votre clavier.
1.2 La stricte base >> vers le sommaire
Il faut commencer par créer un nouveau projet. Pour cela,
faites le comme vous l'avez appris dans le premier tutorial. Voici en très
grandes lignes le principe (repportez vous au premier tutorial si vous avez
tout oublié) :
- File>New -> Win32 Console Application. Entrer le nom -> ok ->
An empty projet -> finish -> ok
- File>New -> C++ Source File. Entrer le nom -> ok
Vous avez maintenant votre page blanche. Tout programme un peu
sérieux commence par un commentaire et vous allez donc laisser votre
petite emprunte. Un commentaire sur une seule ligne doit commencer par //
Un autre type de commentaire, qui n'est pas limité par les lignes,
doit commencer par /* et se finir par */
Voici un exemple de deux commentaires équivalents :
// AqualonneMath est une création réservée par
Aqualonne
// Copyright Aqualonne 2003.
et
/* AqualonneMath est une création réservée par
Aqualonne
Copyright Aqualonne 2003. */
Nous obtons pour le deuxième qui est un type classique
; la plupart du temps, on met en valeur le commentaire avec d'autres étoiles.
Voici donc ce que donne le début du programme :
Vous aurez ensuite besoin d'une bibliothèque pour utiliser
cout et cin. Ajoutez la donc à votre programme comme nous l'avons vu
dans le premier tutorial puis créez la fonction principale. Nous avons
le corps de base :
Récapitulatif sur les commentaires
:
- Les commentaires qui commencent par // sont limités à une
ligne
- Les commentaires qui commencent par /* et se finissent par */ n'ont pas
de limite
1.3 Le menu >> vers le sommaire
Cela devient intéressant à partir d'ici. Nous allons présenter un menu qui contiendra les options demandées par le cahier des charges, ce qui implique qu'à chaque fois que l'utilisateur aura fini d'utiliser une fonctionnalité, le menu sera de nouveau oppérationel et il ne pourra en sortir qu'en demandant à quitter. Réfléchissez au code qui peut permettre de répondre à ce besoin.
La réponse est tout naturellement l'usage d'une boucle
et, actuellement, vous ne connaissez que la boucle for
apprise au tutorial 4. On va surtout se centraliser sur deux cas : la condition
est valide ou elle ne l'est pas ; elle sera valide tant que l'utilisateur
n'aura pas demandé à quitter. Imaginez la solution pour la boucle.
Voici celle que je propose :
Le système est très simple : tant que l'utilisateur
n'a pas demandé à quitter, la variable i
continue à valoir 0 et lorsqu'il demande, elle vaut 3. A présent,
affichons le nom du programme sur la première ligne et le menu sur
la suivante. Voici où nous en sommes :
1.4 Gestion du menu >> vers le sommaire
Prenez en compte le choix de l'utilisateur et créez la
structure du switch qui permettra de le gérer,
en incorporant déjà la possibilité de quitter et le cas
"non prévu". Savoir faire ceci est une base assez importante
; si vous n'y arrivez pas, je vous conseilles particulièrement de revoir
le troisième tutorial. Le code est le suivant :
Vous pouvez déjà compiler et tester le programme pour vous assurez de son bon fonctionnement.
1.5 Calculer les racines de polynômes du second degré >> vers le sommaire
Le cour correspondant est du niveau de 1ère S et explique,
en condensé, les calculs que le programme devra faire :
Dans le traitement de la partie correspondante du programme, commencez par montrer la forme du polynôme puis demandez les valeurs de ses coefficients et, enfin, calculez et affichez delta.
Voici le code correspondant :
S'il y a quelque chose que vous ne comprenez pas, repportez
vous au second tutorial. Avant de continuer à taper le code, nous remarquons
qu'on utilisera le fonction "racine carré" ; or, vous ne
savez pas l'utiliser au point de vue informatique. Certes, il est possible
de créer une boucle for qui y parvienne, mais c'est
inutile quand il existe déjà une fonction dédiée
spécialement à la racine.
Cependant, cette fonction se trouve dans une bibliothèque
particulière. En effet, il faut bien prendre conscience qu'il y a plusieurs
bibliothèques, spécialisées chacune dans un domaine.
Ajoutez donc la bibliothèque math.h de la même
manière que vous avez mit la bibliothèque iostream.h.
Votre début de code sera identique à celui ci-dessous :
En anglais, racine carré se dit "square root"
et la fonction est une abréviation : sqrt. Voici
un exemple de son utilisation :
int k(100), j(0);
j=sqrt(k);
La variable j aura la valeur 10. Il suffit
juste de retenir que sqrt(x) donne la racine carré
de x. Vous pouvez maintenant finir la gestion des racines
de polynômes du second degré tranquillement. La solution que
je propose a un problème et nous allons le voir. Pour commencer, j'ajoute
deux variables :
Ensuite, j'effectue les calculs :
Compilez et testez ce programme : dès la compilation
vous serez averti que des données sont perdues. En effet, les variables
sont des int qui ne prennent aucun nombre à virgule
et donc tous les résultats seront tronqués ! Comment régler
ce programme ?
Tout simplement en prenant d'autres variables qui acceptent
les virgules et les grands nombres : il faut donc que temp1
et temp2 soient des variables de type double.
Voici les nouvelles lignes :
Récapitulatif sur la fonction racine
carré :
- Elle nécessite d'ajouter la bibliothèque math.h
- sqrt(x) donnera la racine carré de x.
1.6 Opérations sur les triangles >> vers le sommaire
Voici un triangle quelconque :
Dans la partie correspondante, demandez à l'utilisateur
la longueur des trois côtés et stockez la. Votre code soit ressembler
au suivant :
Maintenant, nous allons voir si le triangle est rectangle. Le
plus simple à faire est d'abord d'afficher s'il n'est pas rectangle,
mais pour cela il faut tenir compte de trois cas de figures. En effet, le
triangle peut être rectangle en trois points différents ce qui
implique trois calculs de vérifications. Voici un dessin :
Il est possible de faire plusieurs vérifications avec
la même instruction par exemple if, on dit juste
qu'on associe des conditions. L'associativité est soit "ou",
soit "et". Prenons un exemple simple : si A et B sont vrais alors
la condition est vraie, on utilise une associativité "et"
qui demande impérativement à ce que les deux soient vrais ;
cette associativité s'écrit &&.
Dans notre cas, la condition va être "aucun des triangles envisageables
ne peut-être rectangle". On utilise le grand classique de pythagore
qui dit que si a²+b²=c² alors le triangle et rectangle ; voici
donc le code :
Il ne reste plus qu'à faire trois petites vérifications
pour savoir si le triangle est rectangle en certains points. Effectuez le,
vous devez trouver le même code que ci-dessous :
Récapitulatif sur les conditions
de vérification :
- On peut les associer a l'aide de deux opérations : "ou",
"et".
- L'opérateur "et" s'écrit &&.
1.7 Amélioration du menu >> vers le sommaire
En programmation, on tente toujours de faire un programme qui
prenne le moins de place possible pour une efficacité optimale ; comme
dans toutes industries, il s'agit d'une course au rendement. Lorsque nous
avons crée le menu, la variable choisie était de type int.
Or, il existe aussi des variables booléennes. Un rappel sur ces variables,
aussi appellées boolean en anglais : elles ne prennent que deux valeurs,
"vrai" ou "faux". C'est exactement ce dont nous avons
besoin : soit l'utilisateur n'a pas demandé a quitter, soit il a demandé
; de plus, elles utilisent nettement moins de place en mémoire. Cette
variable se déclare par bool pour signifier son
type et ses atributions de valeurs sont true ou false.
Voici un code d'exemple :
bool exemple;
exemple=true;
En voici un autre plus court : bool exemple(false);
Maintenant, remplacez dans notre code le type de variable, de
int vers bool. Voici l'adaptation
du code au début :
Et complété par l'adaptation à la fin :
Nous allons réaliser une autre modification. La boucle
for pour le menu n'est pas la seule possible ; il existe
aussi la boucle do while. Les deux font tourner leur partie
de code tant que la condition n'est pas vérifiée mais for
peut modifier la condition tandis que dans le do while
elle est statique. Prenons un exemple simple avec deux codes. Le premier utilise
for :
for(int i=0;i!=3;i++)
{
}
Le second utilise do while :
int i(0);
do
{
i++;
}while(i!=3);
Ces deux codes donnent des résultats strictements équivalents
mais sans fonctionner de la même manière. La syntaxe théorique
de do while est la suivante :
docondition
{
}while();
On utilise for quand on veut que la boucle
agisse sur la variable de condition ; lorsqu'on ne souhaite pas agir sur la
variable, le mieux est do while. A présent, remplacez
la boucle for par une boucle do while.
Voici le code du début modifié :
Et celui de la fin :
Le programme est fini. Vous devez maintenant avoir les compétences nécessaires à la réalisation d'un programme comportant des opérations mathématiques rudimentaires, et disposant d'un menu.
Récapitulatif sur les derniers
points vus :
- Le variable booléenne déclarée par bool
(exemple : bool mavariable) ne peut prendre que deux valeurs,
true et false.
- La syntaxe de do while est
docondition
{
}while();
- On utilise for quand on veut que la boucle agisse sur
la variable de condition ; lorsqu'on ne souhaite pas agir sur la variable,
le mieux est do while.
II. Autres opérateurs >> vers le sommaire
2.1 Compléments aux opérations mathématiques >> vers le sommaire
Il existe encore beaucoup d'opérations qui nécessitent
plus que la simple racine carré. Les principales concernent la trigonométrie
et utilisent sinus, cosinus et tangente. Fermez le projet où vous êtes
actuellement et ouvrez le projet Base puis nettoyez le de façon à
ce qu'il ne comporte que les lignes ci-dessous :
#include <iostream.h>
main()
{
}
Maintenez, créez trois variables x,
y et z de type double
et ajoutez la bibliothèque des fonctions mathématiques que nous
avons vu précédemment. Voici le code que vous devez avoir :
#include <iostream.h>
#include <math.h>
main()
{
double x(0.0),y(0.0), z(0.0);
}
Les fonctions sinus, cosinus et tangente sont utilisables de
la même manière que la racine carrée. Voici trois exemples
:
- sin(3.14) renverra comme valeur le sinus de 3,14
- tan(2,56) renverra comme valeur le sinus de 2,56
- cos(1,75) renverra comme valeur le sinus de 1,75
Sachant ceci, attribuez respectivement aux variables x,
y et z le cosinus, sinus et tangente
de 1, puis affichez ces résultats. Le code sera le suivant :
#include <iostream.h>
#include <math.h>
main()
{
double x(0.0),y(0.0), z(0.0);
x=cos(1);
y=sin(1);
z=tan(1);
cout << "cos de 1 : " << x << "\nsin de 1
: " << y << "\ntan de 1 : " << z <<
"\n";
}
Executez le programme pour voir les résultats s'afficher.
Il est à noter que les valeurs d'entrées fournies au cosinus,
sinus et tangente sont exprimées en radians. Nous allons donc chercher
à obtenir le cosinus, sinus et tangente en entrant des mesures en radians.
Au préalable, il faut introduire pi. Voici donc la ligne à rajouter
avant la création des trois variables pour rajouter pi au programme
:
const double pi=3.14159265358979;
Cette ligne mérite une explication. Lorsque les variables
correspondent à des résultats fixes on dit qu'elles sont constantes
et on rajoute const avant de déclarer leur type.
La suite est courante, on donne le type double, le nom
pi et la valeur. Sachant ceci, transformez le code pour
qu'il affiche le sinus de pi/2, le cosinus de -pi et la tangente de pi. Voici
le code :
#include <iostream.h>
#include <math.h>
main()
{
const double pi=3.14159265358979;
double x(0.0),y(0.0), z(0.0);
x=cos(-pi);
y=sin(pi/2);
z=tan(pi);
cout << "cos de -pi : " << x << "\nsin de
pi/2 : " << y << "\ntan de pi : " << z <<
"\n";
}
Récapitulatif sur les compléments
:
- tan(x) donne comme valeur la tangente de x
- sin(x) donne comme valeur le sinus de x
- cos(x) donne comme valeur le cosinus de x
- déclarer une variable avec const signifie qu'il
s'agit d'une variable constante, dont la valeur ne change pas
2.2 Plus loin dans les associativités de condition >> vers le sommaire
Nous avons vu l'associativité &&
signifiant "et". L'associativité "ou" s'écrit
||. Par exemple, si vous voulez la condition "si
cette variable est vrai ou si cette variable est vrai", vous écrirez
:
if(x==true || y==true)
On distingue deux types de ou. Voyons la phrase "si cette
variable est vrai ou si cette variable est vrai" : avec un "ou"
inclusif, il suffit qu'une des deux variables soit vrai, mais avec un "ou"
exclusif il faut qu'une seule des deux variables soient vrais. En faisant
des tests, quel est le type de "ou" de || ?
Il s'agit d'un "ou" inclusif.
Les opérateurs ont aussi une priorité : le &&
est prioritaire sur le ||. Regardez le code ci-dessous
:
if(x==false || y==true && z==false)
L'ordinateur va réaliser les opérations dans cet
ordre :
1. Est-ce que y==true et z==false
sont des conditions remplies ? Si oui, alors on considère que l'ensemble
est rempli.
2. Si non, est-ce que x==false est une condition remplie
? Si oui, alors on considère que l'ensemble est rempli.
Voici un code aux priorités différentes :
if((x==false || y==true) && z==false)
Voici la manière dont l'ordinateur va procéder
:
1. On regarde si la condition x==false ou la condition
y==true sont remplis. Si c'est le cas, alors la totalité
de la parenthèse est considérée comme remplie.
2. On associe une deuxième condition à la parenthèse
: il faut que z==false soit rempli. Si oui, alors l'ensemble
est rempli.
Il suffit que le contenu de la parenthèse ou z==false
ne soient pas vérifiés pour que la totalité ne soient
pas remplis.
Récapitulatif sur les associations
de condition :
- Le ou inclusif est ||
- Le && ("et") a priorité sur
le || ("ou")
Aller au tutorial suivant (tutorial 5) >>