Cours C++

Apprendre C++ en PDF


Télécharger Apprendre C++ en PDF

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


COURS et TP DE LANGAGE C++

Chapitre 1

Eléments de langage C++

Joëlle MAILLEFERT

IUT de CACHAN

Département GEII 2

CHAPITRE 1

ELEMENTS DE LANGAGE C++

Les exercices ont été testés avec les outils BORLAND C++ BUILDER (toute version) en mode « console » et BC5. Le corrigé des exercices et le listing de ces programmes se trouvent à la fin de chaque chapitre et sont téléchargeables.

Pour avancer un peu plus vite et aborder l’essentiel de la Programmation Orientée Objet (P.O.O.), on pourra étudier les chapitres et paragraphes marqués de ***, dans un deuxième temps.

INTRODUCTION

Le langage C++ est un langage évolué et structuré. C’est en ce sens une évolution du langage C.

Il possède en outre les fonctionnalités de la programmation orienté objet.

Le langage C++ se trouve à la frontière entre le langage C, non objet, et le langage JAVA conçu d’emblée en orienté objet.

On trouve sur le marché un grand nombre de compilateurs C++ destinés à différents microprocesseurs ou microcontrôleurs.

Le langage C++ possède assez peu d'instructions, il fait par contre appel à des bibliothèques, fournies en plus ou moins grand nombre avec le compilateur.

exemples:       math.h  : bibliothèque de fonctions mathématiques              iostream.h : bibliothèque d'entrées/sorties standard                       complex.h : bibliothèque contenant la classe des nombres complexes.

On ne saurait développer un programme en C++ sans se munir de la documentation concernant ces bibliothèques.

ETAPES PERMETTANT L'EDITION, LA MISE AU POINT,  L'EXECUTION D'UN PROGRAMME

1- Edition du programme source, à l'aide d'un éditeur (traitement de textes). Le nom du fichier contient l'extension .CPP, exemple: (menu « edit »).

2- Compilation du programme source, c'est à dire création des codes machine destinés au microprocesseur utilisé. Le compilateur indique les erreurs de syntaxe mais ignore les fonctions-bibliothèque appelées par le programme.

Le compilateur génère un fichier binaire, non éditable en mode « texte », appelé fichier objet: (commande « compile »).

3- Editions de liens: Le code machine des fonctions-bibliothèque est chargé, création d'un fichier binaire, non éditable en mode texte, appelé fichier exécutable: (commande « build all »).

4- Exécution du programme(commande « Run » ou « flèche jaune »).

Les compilateurs permettent en général de construire des programmes composés de plusieurs fichiers sources, d'ajouter à un programme des unités déjà compilées. On dit alors que l’on travaille par gestion de projet.

Exercice I-1: Editer (), compiler et exécuter le programme suivant:

#include   // sorties standards 

#include      // les commentaires s'écrivent derrière 2 barres

ÏÞßàvoid main()

Ïϧ{

ÏϨ¹¹Ïcout<<"BONJOUR";//affichage d'un message sur l'écran

ÏϨ¹¹Ïcout<<" Belle journée!!";//affichage d'un autre message sur l'écran

ÏϨ¹¹Ïcout<<"Pour continuer frapper une touche...";

Ïϧ// Attente d'une saisie clavier pour voir l'écran d'exécution

ÏϨ¹¹Ïgetch();  

ÏÏ©}

Le langage C++ distingue les minuscules, des majuscules. Les mots réservés du langage C++ doivent être écrits en minuscules. 

On a introduit dans ce programme la notion d’interface homme/machine (IHM). 

-  L’utilisateur visualise une information sur l’écran,

-  L’utilisateur, par une action sur le clavier, fournit une information au programme.

Les instructions sont exécutées séquentiellement, c’est à dire les unes après les autres. L’ordre dans lequel elles sont écrites a donc une grande importance.

Echanger les 2 premières instructions, puis exécuter le programme.

Modifier maintenant le programme comme ci-dessous, puis le tester :

//les commentaires s'écrivent derrière 2 barres obliques

#include   //sorties standard  #include  

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint a, b, calcul ;  //déclaration de 3 variables 

ÏϨ¹¹Ïcout<<"BONJOUR";//affichage d'un message sur l'écran

ÏϨ¹¹Ïa = 10 ; // affectation

ÏϨ¹¹Ïb = 50 ; // affectation  ÏϨ¹¹Ïcalcul = (a + b)*2 ;  //

ÏϨ¹¹Ïcout <<" Affichage de a : "<< a<<"\n";

ÏϨ¹¹Ïcout <<" Affichage de b : "<< b<<"\n";

ÏϨ¹¹Ïcout <<" Voici le résultat : "<< calcul<<"\n";

ÏϨ¹¹Ïcout<<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier  ÏÏ©}

Dans ce programme, on introduit 3 nouveaux concepts :

-  La notion de déclaration de variables : les variables sont les données que manipulera le programme lors de son exécution. Ces variables sont rangées dans la mémoire vive de l’ordinateur. Elles peuvent être déclarées au moment où on en a besoin dans le programme. Pour une meilleure lisibilité, il est conseillé de les déclarer au début (sauf peut-être pour des variables créées par commodité et qui ne servent que très localement dans le programme). - La notion d’affectation, symbolisée par le signe =. La source de l’information est à droite du signe =, la destination à gauche.

a = 10;             signifie « a prend la valeur 10 » s = a + b; signifie « s prend la valeur a + b »

s = s + 5; signifie « la nouvelle valeur de s est égale à l’ancienne + 5 »

- La notion d’opération. Un programme informatique est exécuté séquentiellement, c’est à dire une instruction après l’autre. Lorsque l’instruction s = a + b est exécutée, a possède la valeur 10, et b possède la valeur 50.

LES DIFFERENTS TYPES DE VARIABLES

1- Les entiers 

Le langage C++ distingue plusieurs types d'entiers:

___________________________________________________________

TYPE                          DESCRIPTION                      TAILLE MEMOIRE                

 ___________________________________________________________

int                                entier standard signé  4 octets: - 231 ? n ? 231-1         unsigned int            entier positif                          4 octets: 0 ? n ? 232      

short                entier court signé                    2 octets: - 215 ? n ? 215-1   unsigned short  entier court non signé    2 octets: 0 ? n ? 216

char                             caractère signé                        1 octet  : - 27 ? n ? 27-1          unsigned char  caractère non signé                 1 octet  : 0 ?n ? 28                   _____________________________________________________________

Numération:

-       En décimal les nombres s'écrivent tels que,  - En hexadécimal ils sont précédés de 0x.

exemple: 127  en décimal s'écrit 0x7f en hexadécimal.

Remarque: En langage C++, le type char possède une fonction de changement de type vers un entier:

-       Un caractère peut voir son type automatiquement transformé vers un entier de 8 bits - Il est interprété comme un caractère alphanumérique du clavier.

Exemples:

Les caractères alphanumériques s'écrivent entre ‘ ‘ Le caractère 'b' a pour valeur 98.

Le caractère 22 a pour valeur 22.

Le caractère 127 a pour valeur 127.

Le caractère 257 a pour valeur 1 (ce nombre s'écrit sur 9 bits, le bit de poids fort est perdu).

Quelques constantes caractères:

________________________________________________________________

CARACTERE                                    VALEUR (code ASCII)        NOM ASCII

________________________________________________________________

'\n'        interligne                                0x0a                                        LF

'\t' tabulation horizontale 0x09 HT '\v' tabulation verticale  0x0b    VT '\r' retour chariot   0x0d    CR '\f' saut de page   0x0c    FF '\\' backslash   0x5c    \ '\'' cote    0x2c    '

'\"'        guillemets                               0x22                                       "

 _______________________________________________________________

Modifier ainsi le programme et le tester :

#include   // sorties standard 

#include      // les commentaires s'écrivent derrière 2 barres

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint a, b, calcul ;  // déclaration de 3 variables  ÏϨ¹¹Ïchar u ,v ;

ÏϨ¹¹Ïcout<<"BONJOUR"; // affichage d'un message sur l'écran

ÏϨ¹¹Ïa = 10 ; // affectation

ÏϨ¹¹Ïb = 50 ; // affectation 

ÏϨ¹¹Ïu = 67 ;

ÏϨ¹¹Ïv = 'A' ;

ÏϨ¹¹Ïcalcul = (a + b)*2 ; //affectation et opérations  

ÏϨ¹¹Ïcout <<" Affichage de a : "<< a<<"\n";

ÏϨ¹¹Ïcout <<" Affichage de b : "<< b<<"\n";

ÏϨ¹¹Ïcout <<" Voici le résultat : "<< calcul<<"\n";

ÏϨ¹¹Ïcout <<" Affichage de u :"<< u <<"\n";

ÏϨ¹¹Ïcout <<" Affichage de v :"<< v <<"\n" ;

ÏϨ¹¹Ïcout<<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier  ÏÏ©}

2- Les réels

Un réel est composé :

-  d'un signe,      

-  d'une mantisse,                     - d'un exposant,

Un nombre de bits est réservé en mémoire pour chaque élément.

Le langage C++ distingue 2 types de réels:

_________________________________________________________

TYPE              DESCRIPTION                     TAILLE MEMOIRE                            

 _________________________________________________________

float                 réel standard              4 octets                                     double            réel double précision         8 octets                                     

__________________________________________________________

LES INITIALISATIONS 

Le langage C++ permet l'initialisation des variables dès leurs déclarations:

char c;              est équivalent à           char c = 'A'; c = 'A';

int i;                 est équivalent à           int i = 50; i = 50;

Cette règle s'applique à tous les nombres, char, int, float ... Pour améliorer la lisibilité des programmes et leur efficacité, il est conseillé de l’utiliser.

SORTIES DE NOMBRES OU DE TEXTE A L'ECRAN L’OPERATEUR COUT

Ce n'est pas une instruction du langage C++, mais une fonction de la bibliothèque iostream.h.

Exemple: affichage d'un texte:

cout <<"BONJOUR";             // pas de retour à la ligne du curseur après l'affichage cout <<"BONJOUR\n";      // affichage du texte, puis retour à la ligne du curseur Exercice I-2: Tester le programme suivant et conclure.

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïcout<<"BONJOUR " ;

ÏϨ¹¹Ïcout <<"IL FAIT BEAU\n";  

ÏϨ¹¹Ïcout <<"BONNES VACANCES";

ÏϨ¹¹Ïcout <<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier  ÏÏ©}

Exercice I-3: Affichage d'une variable de type int ou float:

Tester le programme suivant et conclure.

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint u = 1000 ;

ÏϨ¹¹Ïfloat s = 45.78 ;

ÏϨ¹¹Ïcout <<"Voici u (en base 10) :  " << u << "\n"; ÏϨ¹¹Ïcout <<"Voici u (en hexa) : "<< hex << u <<"\n";

ÏϨ¹¹Ïcout <<"Voici s : "<< s << "\n";

ÏϨ¹¹Ïcout <<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch();  // Attente d'une saisie clavier

ÏÏ©}   

Affichage multiple: modifier le programme précédent ainsi, et conclure. 

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint u; ÏϨ¹¹Ïfloat s;

ÏϨ¹¹Ïu = 1000; ÏϨ¹¹Ïs = 45.78;

ÏϨ¹¹Ïcout <<"Voici u (base 10) : "<< u << "\nVoici s : " << s << "\n";

ÏϨ¹¹Ïcout <<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier ÏÏ©}

Exercice I-4:

a et b sont des entiers,  a = -21430 b = 4782, calculer et afficher a+b, a-b, a*b, a/b, a%b en soignant l’interface homme/machine.

Indication: a/b donne le quotient de la division, a%b donne le reste de la division. 

Exercice I-5: Affichage d'une variable de type char : tester le programme ci-dessous et conclure.

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïchar u,v,w;

ÏϨ¹¹Ïint i; ÏϨ¹¹Ïu = 'A'; ÏϨ¹¹Ïv = 67; ÏϨ¹¹Ïw = 0x45;

ÏϨ¹¹Ïcout<<"Voici u : "<< u << "\n";

ÏϨ¹¹Ïcout<<"Voici v : "<< v <<"\n";

ÏϨ¹¹Ïcout<<"Voici w : "<< w <<"\n";

ÏϨ¹¹Ïi = u; // conversion automatique de type

Ïϧ   // pour obtenir le code ascii de la lettre A en base 10 

ÏϨ¹¹Ïcout<<"Voici i : "<< i << "\n";

Ïϧ   // pour obtenir le code ascii de la lettre A en hexadécimal

ÏϨ¹¹Ïcout<<"Voici i : "<< hex << i << "\n";

ÏϨ¹¹Ïcout<<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier  ÏÏ©}

Exercice I-6:

Pour votre compilateur C++, la taille des entiers est de 32 bits;   

Que va-t-il se passer, à l'affichage, lors de l'exécution du programme suivant ?

#include   

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint a = 12345000, b = 60000000, somme;

ÏϨ¹¹Ïsomme=a*b;

ÏϨ¹¹Ïcout<<"a*b = "<<somme<<"\n";

Ïϧ

ÏϨ¹¹Ïcout <<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); /* Attente d'une saisie clavier */ ÏÏ©}

Exercice I-7:

a et b sont des réels,  a = -21,43 b = 4,782, calculer et afficher a+b, a-b, a*b, a/b, en soignant l’interface homme/machine.



LES OPERATEURS

Opérateurs arithmétiques sur les réels: +  -  *  /   avec la hiérarchie habituelle.

Opérateurs arithmétiques sur les entiers: +  -  *  / (quotient de la division)  % (reste de la division) avec la hiérarchie habituelle.

Exemple particulier:               char c, d;         c = 'G';            d = c+'a'-'A';

Les caractères sont des entiers sur 8 bits, on peut donc effectuer des opérations. Sur cet exemple, on transforme la lettre majuscule G en la lettre minuscule g.

Opérateurs logiques sur les entiers:

& ET  | OU  ^ OU EXCLUSIF           ~ COMPLEMENT A UN        « DECALAGE A GAUCHE » DECALAGE A DROITE.

Exemples:       p = n « 3;         // p est égale à n décalé de 3 bits à gauche                 p = n » 3;         // p est égale à n décalé de 3 bits à droite 

L'opérateur sizeof(type) renvoie le nombre d'octets réservés en mémoire pour chaque type d'objet. 

Exemple: n = sizeof(char);     /* n vaut 1 */

Exercice I-8: n est un entier (n = 0x1234567a), p est un entier (p = 4). Ecrire un programme qui met à 0 les p bits de poids faibles de n.

Exercice I-9: quels nombres va renvoyer le programme suivant ?

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïcout<<"TAILLE D'UN CARACTERE : "<<sizeof(char)<< "\n";

ÏϨ¹¹Ïcout<<"TAILLE D'UN ENTIER : "   <<sizeof(int)<< "\n";

ÏϨ¹¹Ïcout<<"TAILLE D'UN REEL : "     <<sizeof(float)<< "\n";

ÏϨ¹¹Ïcout<<"TAILLE D'UN DOUBLE : "   <<sizeof(double)<< "\n";

ÏϨ¹¹Ïcout <<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier  ÏÏ©}

INCREMENTATION - DECREMENTATION

Le langage C++ autorise des écritures simplifiées pour l'incrémentation et la décrémentation de variables de type entier (int, char, long)

i =  i+1;  est équivalent à   i++;                                  

i =  i-1;  est équivalent à    i--;

OPERATEURS COMBINES

Le langage C++ autorise des écritures simplifiées  lorsqu'une même variable est utilisée de chaque côté du signe = d'une affectation. Ces écritures sont à éviter lorsque l'on débute l'étude du langage C++ car elles nuisent à la lisibilité du programme.

a =  a+b;          est équivalent à           a+= b; a =  a-b; est équivalent à           a-= b; a =  a & b;         est équivalent à a&= b;

LES DECLARATIONS DE CONSTANTES

Le langage C++ autorise 2 méthodes pour définir des constantes.

1ere méthode: déclaration d'une variable, dont la valeur sera constante pour toute la portée de la fonction main.

Exemple :       

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïconst float PI = 3.14159;

ÏϨ¹¹Ïfloat perimetre, rayon = 8.7; ÏϨ¹¹Ïperimetre = 2*rayon*PI; Ïϧ// ...

ÏÏ©}

Dans ce cas, le compilateur réserve de la place en mémoire (ici 4 octets), pour la variable pi, on ne peut changer la valeur. On peut associer un modificateur« const » à tous les types.

2eme méthode: définition d'un symbole à l'aide de la directive de compilation #define.

Exemple:        

#define PI = 3.14159;

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïfloat perimetre,rayon = 8.7; ÏϨ¹¹Ïperimetre = 2*rayon*PI; Ïϧ// ....

ÏÏ©}

Le compilateur ne réserve pas de place en mémoire, on définit ainsi une équivalence

« lexicale ». 

Les constantes déclarées par #define s'écrivent traditionnellement en majuscules, mais ce n'est pas une obligation.

LES CONVERSIONS DE TYPES

Le langage C++ permet d'effectuer automatiquement des conversions de type sur les scalaires:

Exemple et exercice I-11:

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïchar c=0x56,d=25,e;

ÏϨ¹¹Ïint i=0x1234,j;

ÏϨ¹¹Ïfloat r=678.9,s;

ÏϨ¹¹Ïj = c; // j vaut 0x0056, utilisé précédemment  pour afficher 

Ïϧ          // le code ASCII d’un caractère

ÏϨ¹¹Ïj = r; // j vaut 678 

ÏϨ¹¹Ïs = d; // s vaut 25.0 

ÏϨ¹¹Ïe = i; // e vaut 0x34 

ÏÏ©}

Une conversion de type float --> int ou char peut-être dégradante. Une conversion de type int ou char --> float est dite nondégradante.

CORRIGE DES EXERCICES

Exercice I-4:

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint a,b;

ÏϨ¹¹Ïa= -21430;

ÏϨ¹¹Ïb= 4782;

ÏϨ¹¹Ïcout<<"A + B = "<< a+b <<"\n";

ÏϨ¹¹Ïcout<<"A - B = "<< a-b <<"\n";

ÏϨ¹¹Ïcout<<"A x B = "<< a*b <<"\n";

ÏϨ¹¹Ïcout<<"A sur B = "<< a/b <<"\n" ;

ÏϨ¹¹Ïcout<<"A mod B = "<< a%b <<"\n";

ÏϨ¹¹Ïcout<<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier  ÏÏ©}

Exercice I-7:

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïfloat a,b; 

Ïϧ

ÏϨ¹¹Ïa= -21430;

ÏϨ¹¹Ïb= 4782; 

Ïϧ

ÏϨ¹¹Ïcout<<"A + B = "<< a+b <<"\n";

ÏϨ¹¹Ïcout<<"A - B = "<< a-b <<"\n";

ÏϨ¹¹Ïcout<<"A x B = "<< a*b <<"\n";

ÏϨ¹¹Ïcout<<"A sur B = "<< a/b <<"\n" ;

Ïϧ

ÏϨ¹¹Ïcout<<"Pour continuer frapper une touche...";

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier  ÏÏ©}

Exercice I-8:

#include

#include

ÏÞßàvoid main() Ïϧ{ ÏϨ¹¹Ïint n,p,masque; 

Ïϧ

ÏϨ¹¹Ïn= 0x1234567a;

ÏϨ¹¹Ïp = 4; 

Ïϧ

ÏϨ¹¹Ïcout<<"valeur de n avant modification:"<< hex << n <<"\n";

ÏϨ¹¹Ïn = n >> p;

ÏϨ¹¹Ïn = n << p; 

Ïϧ

ÏϨ¹¹Ïcout<<"n modifié vaut:"<< hex << n <<"\n";

ÏϨ¹¹Ïcout <<"Pour continuer frapper une touche..."; 

Ïϧ

ÏϨ¹¹Ïgetch(); // Attente d'une saisie clavier  ÏÏ©}

Exercice I-9:

Avec le compilateur C++ utilisé : 

•   sizeof(char) vaut 1  

•   sizeof(int) vaut 4   

•   sizeof(float) vaut 4   

•   sizeof(double) vaut 8.

COURS et TP DE LANGAGE C++

Chapitre 2

Saisie de nombres et de caractères au clavier

Joëlle MAILLEFERT

IUT de CACHAN

Département GEII 2

CHAPITRE 2

SAISIE DE NOMBRES ET DE CARACTERES AU

CLAVIER

LA FONCTION GETCH

La fonction getch, appartenant à la bibliothèque conio.h permet la saisie clavier d’un caractère alphanumérique, sans écho écran. La saisie s'arrête dès que le caractère a été frappé.

La fonction getch n'est pas définie dans la norme ANSI mais elle  existe dans les bibliothèques des compilateurs.

On peut utiliser getch de deux façons:

sans retour de variable au programme:

Exemple:         cout<<"POUR CONTINUER FRAPPER UNE TOUCHE ";

                        getch();

avec retour de variable au programme:

Exemple:         char alpha;

                        cout<<"ENTRER UN CARACTERE (ATTENTION PAS DE

RETURN)";               alpha = getch();

                        cout<<"\nVOICI CE CARACTERE: "<<alpha;

Les parenthèses vides de getch() signifient qu'aucun paramètre n'est passé à cette fonction par le programme appelant.

L’OPERATEUR CIN

L’opérateur cin, spécifique à C++, appartient à la bibliothèque iostream.h, et permet la saisie à partir du clavier de n'importe quel type de variable (l’affichage prend en compte le type de la variable). 

La saisie s'arrête avec "RETURN" (c'est à dire LF), les éléments saisis s'affichent à l'écran (saisie avec écho écran). 

Tous les éléments saisis après un  caractère d'espacement (espace, tabulation) sont ignorés.

Exemples:       char alpha;

                        int i;

                        float r;

                        cin >>alpha;    // saisie d'un caractère  cin >>i;                       // saisie d'un nombre entier en décimal 

                        cin >>r;                       // saisie d'un nombre réel 

Remarque: Si l'utilisateur ne respecte pas le type de la variable, aucune erreur n'est générée.

Le programme peut se comporter de plusieurs façons :

Exemples:       int u;

                        cin >> u;  

Si l'utilisateur saisi un caractère non numérique, sa saisie est ignorée.

                        char c;

                        cin >> c;  

Si l'utilisateur saisi par exemple 68, le caractère ‘6’ sera affecté à la variable c. Conséquence : pour une interface homme machine (IHM) d’un produit fini, ne jamais utiliser « cin ».

Exercice II_1:

Saisir un caractère au clavier, afficher son code ASCII à l'écran. Soigner l'affichage.

Exercice II_2:

Dans une élection, I est le nombre d’inscrits, V le nombre de votants,

P = 100V/I le pourcentage de votants, M = V/2 le nombre de voix pour obtenir la majorité.

Ecrire un programme qui demande à l’utilisateur de saisir I et V, puis calcule et affiche P et M.

Exercice II_3:

Saisir 3 réels, calculer et afficher leur moyenne.

CORRIGE DES EXERCICES

Exercice II_1:

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïchar c;

ÏϨ¹¹Ïint u;

ÏϨ¹¹Ïcout<<"ENTRER UN CARACTERE : "; ÏϨ¹¹Ïcin >> c;

ÏϨ¹¹Ïu = c;    //conversion automatique de type

ÏϨ¹¹Ïcout<<"VOICI SON CODE ASCII : "<< u << "\n";

ÏϨ¹¹Ïcout<<"Pour continuer frapper une touche..."; ÏϨ¹¹Ïgetch();

ÏÏ©}

Exercice II_2:

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint I,V,M,P;

ÏϨ¹¹Ïcout<<"Entrer le nombre d'inscrits : ";

ÏϨ¹¹Ïcin>>I;

ÏϨ¹¹Ïcout<<"Entrer le nombre de votants : "; ÏϨ¹¹Ïcin>>V; ÏϨ¹¹ÏP = V*100/I;

ÏϨ¹¹ÏM = V/2 + 1; // Division entière

ÏϨ¹¹Ïcout<<"Participation : "<<P<<"% - Majorité: "; 

ÏϨ¹¹Ïcout<<M<<" bulletins\n";

ÏϨ¹¹Ïcout<<"POUR CONTINUER FRAPPER UNE TOUCHE "; ÏϨ¹¹Ïgetch();

ÏÏ©}

Exercice II_3:

#include

#include

ÏÞßàvoid main() Ïϧ{ ÏϨ¹¹Ïfloat r1, r2, r3, moy;

Ïϧ

ÏϨ¹¹Ïcout<<"ENTRER UN NOMBRE REEL : ";

ÏϨ¹¹Ïcin >> r1; 

Ïϧ

ÏϨ¹¹Ïcout<<"ENTRER UN NOMBRE REEL : ";

ÏϨ¹¹Ïcin >> r2; 

Ïϧ

ÏϨ¹¹Ïcout<<"ENTRER UN NOMBRE REEL : ";

ÏϨ¹¹Ïcin >> r3;

Ïϧ

ÏϨ¹¹Ïmoy = (r1 + r2 + r3) / 3;

Ïϧ

ÏϨ¹¹Ïcout<<"MOYENNE DE CES 3 NOMBRES : "<<moy<<"\n";

ÏϨ¹¹Ïcout<<"Pour continuer frapper une touche ..."; 

ÏϧÏϨ¹¹Ïgetch();

ÏÏ©}

COURS et TP DE LANGAGE C++

Chapitre 3

Les tests et les boucles

Joëlle MAILLEFERT

IUT de CACHAN

Département GEII 2

CHAPITRE 3

LES TESTS ET LES BOUCLES

Un programme écrit en C++ s’exécute séquentiellement, c’est à dire instruction après instruction.

Ce chapitre explique comment, dans un programme, on pourra :

-       ne pas exécuter une partie des instructions, c’est à dire faire un saut dans le programme,

-       revenir en arrière, pour exécuter plusieurs fois de suite la même partie d’un programme.

L'INSTRUCTION SI ... ALORS ... SINON ...

Il s'agit de l'instruction:          si (condition vraie)                

alors {BLOC 1 D'INSTRUCTIONS}          

Organigramme:

sinon {BLOC 2 D'INSTRUCTIONS}

Syntaxe en C: 

if (condition)

            {

            ............;

// bloc 1 d'instructions 

            ............;

            ............;

            }            

            else

{

                                                ............;                      // bloc 2 d'instructions 

                                                ............;



                                                ............;

                                                }                                               suite du programme ...

Si la condition est vraie, seul le bloc1 d’instructions est exécuté, si elle est fausse, seul le bloc2 est exécuté.

Dans tous les cas, la suite du programme sera exécutée.

Le bloc "sinon" est optionnel:            si (condition)

                                                            alors {BLOC D'INSTRUCTIONS}

Syntaxe en C:              if (condition)

                                                {

                                                ............;                      // bloc d'instructions 

                                                ............;

                                                ............;

                                                }                                  suite du programme...

Si la condition est vraie, seul le bloc1 d’instructions est exécuté, si elle est fausse, on passe directement à la suite du programme.

Remarque: les {} ne sont pas nécessaires lorsque les blocs ne comportent qu'une seule instruction.

LES OPERATEURS LOGIQUES

condition d'égalité:                             if (a==b)         " si a est égal à b "

condition de non égalité:                    if (a!=b)          " si a est différent de b "

conditions de relation d'ordre:            if (a<b)           if (a<=b)         if (a>b)           if (a>=b)

plusieurs conditions devant être vraies simultanément, ET LOGIQUE:       

if ((expression1) && (expression2))       " si l'expression1 ET l'expression2 sont vraies "

une condition devant être vraie parmi plusieurs, OU LOGIQUE       if ((expression1) || (expression2))            " si l'expression1 OU l'expression2 est vraie "

condition fausse          if (!(expression1))     " si l'expression1 est fausse "

Toutes les combinaisons sont possibles entre ces tests.

Exercice III-1: L'utilisateur saisit un caractère, le programme teste s'il s'agit d'une lettre majuscule, si oui il renvoie cette lettre en minuscule, sinon il renvoie un message d'erreur.

Exercice III-2: Dans une élection, I est le nombre d’inscrits, V le nombre de votants, Q le quorum, P = 100V/I le pourcentage de votants, M = V/2 + 1 le nombre de voix pour obtenir la majorité absolue.

Le quorum est le nombre minimum de votants pour que le vote soit déclaré valable.

Ecrire un programme qui 

1-  demande à l’utilisateur de saisir I, Q et V,

2-  teste si le quorum est atteint,

3-  si oui calcule et affiche P, M, sinon affiche un message d’avertissement.

L'INSTRUCTION REPETER ... TANT QUE ...

Il s'agit de l'instruction:           exécuter {BLOC D'INSTRUCTIONS}                                          tant que (condition vraie) 

Syntaxe en C:             do

                                                {

                                                ............;                      // bloc d'instructions 

                                                ............;

                                                ............;

                                                }                                   

                                    while (condition);                   suite du programme ...

Le test se faisant après, le bloc est exécuté au moins une fois.

Remarque: les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.

LA BOUCLE TANT QUE ... FAIRE ...

Il s'agit de l'instruction:          tant que (condition vraie) 

                                                Exécuter {BLOC D'INSTRUCTIONS}  

Syntaxe en C:             while (condition)

                                                {

                                                ............;                      // bloc d'instructions 

                                                ............;

                                                ............;

                                                }                                  suite du programme ...                                     

Le test se fait d'abord, le bloc d'instructions n'est pas forcément exécuté.

Remarque: les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.

Remarque: On peut rencontrer la construction suivante: while (expression); terminée par un ; et sans la présence du bloc d'instructions. Cette construction signifie: "tant que l'expression est vraie attendre". Ceci ne doit être exploité que par rapport à des événements externes au programme (attente de la frappe du clavier par exemple).

L'INSTRUCTION POUR ...

Il s'agit de l'instruction:           

pour (instruction1; condition; instruction2)                                  

{BLOC D'INSTRUCTIONS}                                                 

Syntaxe en C: 

for(instruction1; condition; instruction2)

                                                {

                                                ............;                      // bloc d'instructions 

                                                ............;

                                                ............;

                                                }                                               suite du programme ...                                     

Remarques: 

Il s’agit d’une version enrichie du « while ».

Les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.

Les 3 instructions du for ne portent pas forcément sur la même variable.

Une  instruction peut être omise, mais pas les ;

Exemples:for(int i = 0 ; i

{

                                                ............;                      // bloc d'instructions 

                                                ............;

                                                ............;

                                                }                                              suite du programme ...

correspond à l'organigramme suivant:

La boucle                                for(;;)

{

                                                ............;                      // bloc d'instructions 

                                                ............;

                                                ............;

                                                }

est une boucle infinie (répétition infinie du bloc d'instructions).

Utilisation de variables différentes:

resultat = 0;

for(int i = 0 ; resultat

{

                                                ............;                      // bloc d'instructions 

                                                ............;                                    ............;                                               resultat = resultat + 2*i;

                                                }

Exercice III-3:

Ecrire un programme permettant de saisir un entier n, de calculer n!, puis de l’afficher.

Utiliser une boucle do ...while puis while puis for.

Quelle est la plus grande valeur possible de n, si n est déclaré int, puis unsigned int?

Exercice III-4:

La formule récurrente ci-dessous permet de calculer la racine du nombre 2 :



U0 = 1

Ui = ( Ui-1+ 2/Ui-1 ) / 2

Ecrire un programme qui saisit le nombre d’itérations, puis calcule et affiche la racine de 2.

L'INSTRUCTION AU CAS OU ... FAIRE ...

L'instruction switch permet des choix multiples uniquement sur des entiers (int) ou des caractères (char).

Syntaxe:

switch(variable de type char ou int)           au cas où la variable vaut:

{ case  valeur1: ......;                          - cette valeur1: exécuter ce bloc d'instructions.

.......;

                        break;                        - se brancher à la fin du bloc case.valeur2:........;     - cette valeur2:  exécuter ce bloc d'instructions.

........;                          break;                                    - se brancher à la fin du bloc case.

            .

            .                                                           etc ...

            .

       default:  .......;                              - aucune des valeurs précédentes: exécuter ce bloc            ........;                   d'instructions, pas de "break" ici.

}

le bloc "default" n'est pas obligatoire.

L’instruction switch correspond à une cascade d’instructions if

Exemple:

Cette instruction est commode pour fabriquer des "menus":

char choix;

cout<<"LISTE PAR GROUPE TAPER 1\n"; cout<<"LISTE ALPHABETIQUE TAPER 2\n"; cout<<"POUR SORTIR TAPER S\n";

cout<<"\nVOTRE CHOIX : "; cin >> choix;

switch(choix)

{

case '1':  .......;

                .......;

               break;

case '2':  ......;

                 ......;

                break;

case 'S': cout<<"\nFIN DU PROGRAMME ....";                 break;

default; cout<<"\nCE CHOIX N'EST PAS PREVU ";  // pas de break ici 

}

COMPLEMENT SUR LES TESTS

En langage C++, une expression nulle de type entier (int) est fausse, une expression non nulle de type entier (int) est vraie.

Exemples:

int a,b,c,delta;            

est équivalent à

int a,b,c,delta;

delta = b*b-4*a*c; 

delta = b*b-4*a*c;

if(delta != 0)               

if(delta)

{ ....... }                         

{ ....... }

int a,b,c,delta;            

est équivalent à

int a,b,c,delta;

delta = b*b-4*a*c; 

delta = b*b-4*a*c;

if(delta == 0)              

if(!delta)

{ ....... }                         

{.......}

En langage C++, le type booléen a été introduit. Il prend les valeurs TRUE ou FALSE. Par exemple : bool test ; test = (x<45) ; if ( test == TRUE)

{……..}

ou plus simplement              ou aussi if( (x<45) == TRUE) )          if (x<45) // !!!!!

EXERCICES RECAPITULATIFS

Exercice III_5: résoudre ax2 + bx +c = 0.

Exercice III_6: La fonction kbhit appartient à la bibiothèque conio.h. Une fonction équivalente peut exister avec d'autres compilateurs. La fonction kbhit teste si un caractère a été frappé au clavier. Tant que ce n'est pas vrai kbhit renvoie 0 (ceci signifie que la valeur retournée par la fonction kbhit est 0).

Exemple:  while(kbhit() == 0) // tant qu'aucun caractère n'a été frappé exécuter la boucle

                        { ..... }

Cette écriture est équivalente à:          

 while(!kbhit())          // tant que kbhit est faux,  exécuter la boucle 

{.....} Ecrire un programme qui affiche le carré des entiers 1, 2, 3 ......, toutes les 500 ms tant qu'aucun caractère n'a été frappé au clavier. Générer la temporisation à l’aide d’une boucle for et d’un décompteur.

CORRIGE DES EXERCICES

Exercice III-1:

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïchar c,d;

ÏϨ¹¹Ïcout <<"ENTRER UNE LETTRE MAJUSCULE :";

ÏϨ¹¹Ïcin>>c; 

ÏϧÏϨ¹¹Ïd = c + 'a' - 'A'; 

Ïϧ

ÏϨ¹³¹if((c>='A') && (c<='Z')) cout<<"LETTRE EN MINUSCULE : "<<d<<"\n"; ÏϧÏö¹else cout<<"CE N'EST PAS UNE LETTRE MAJUSCULE\n"; 

Ïϧ

ÏϨ¹¹Ïcout<<"POUR CONTINUER FRAPPER UNE TOUCHE ";

ÏϨ¹¹Ïgetch();

ÏÏ©} 

Exercice III-2:

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint I, V, M, P, Q;

ÏϨ¹¹Ïcout<<"Entrer le nombre d'inscrits : ";Ïcin>>I; 

ÏϨ¹¹Ïcout<<"Entrer le nombre de votants : "; cin>>V;  ÏϨ¹¹Ïcout<<"Entrer le quorum : ";Ïcin>>Q; 

ÏϨ¹¹ÏP = V*100/I;

ÏϨ¹¹ÏM = V/2 +1;

ÏϨ¹³´if(P > Q) ÏϧÏ6§{

ÏϧÏ6¨¹¹Ïcout<<"Quorum atteint - vote valable\n";

ÏϧÏ6¨¹¹Ïcout<<"Participation: "<<P<<"% - Majorite obtenue pour : ";

ÏϧÏ6¾¹¹Ïcout<< M <<" bulletins\n";

ÏϧÏ6Ï} ÏϧÏöélse

Ïϧϸ§{

Ïϧϸ¾¹¹Ïcout<<"Quorum non atteint - vote non valable\n"; ÏϧÏÈÏ}

ÏϨ¹¹Ïcout<<"POUR CONTINUER FRAPPER UNE TOUCHE ";

ÏϨ¹¹Ïgetch();

ÏÏ©}

Exercice III_3

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint n, fac= 1;

ÏϨ¹¹Ïcout<<"ENTRER UN ENTIER : ";cin>>n;

ÏϨ¹¹#for (int i=1;i<=n;i++) fac= fac * i;

ÏϨ¹¹Ïcout<<"\nn ="<<n<<" n!= "<<fac;

ÏϨ¹¹Ïcout<<"\nPOUR CONTINUER FRAPPER UNE TOUCHE ";

ÏϨ¹¹Ïgetch();

ÏÏ©}

Les entiers sont des nombres de 32 bits:

n int : n! maximum= 12! n unsigned int : n! maximum = 12!

Exercice III_4

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint n,;

ÏϨ¹¹Ïfloat U0=1.0, Ui;

ÏϨ¹¹Ïcout <<"ENTRER LE NOMBRE D'ITERATIONS: ";cin >> n;

ÏϨ¹¹±for (int i=0;i<n;i++) ÏϧÏÏ5{

ÏϧÏÏ7¹¹ÏUi = (U0 + 2.0/U0)/2.0;

ÏϧÏÏ7¹¹ÏU0 = Ui;

ÏϧÏÏ°} 

Ïϧ

ÏϨ¹¹Ïcout <<"RESULTAT = "<< Ui <<"\n";

ÏϨ¹¹Ïcout <<"\nPOUR CONTINUER FRAPPER UNE TOUCHE "; 

ÏϧÏϨ¹¹Ïgetch();

ÏÏ©}

Exercice III_5

#include

#include

#include // contient la fonction racine

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïfloat a,b,c,x1,x2; Ïϧ// saisie de A, B et C

ÏϨ¹¹Ïcout<<"\t\t\tRESOLUTION DE L'EQUATION DU SECOND DEGRE\n";

ÏϨ¹¹Ïcout<<"\t\t\t 2\n";

ÏϨ¹¹Ïcout<<"\t\t\t             AX +BX+C=0\n\n\n"; ÏϨ¹¹Ïcout<<"SAISIR A B C SEPARES PAR RETURN\n";

ÏϨ¹¹Ïcout<<"A = "; cin>>a;

ÏϨ¹¹Ïcout<<"B = "; cin>>b;

ÏϨ¹¹Ïcout<<"C = "; cin>>c; 

Ïϧ

Ïϧ// début du calcul : cas particuliers 

ÏϨ¹³¹if((a==0)&&(b==0)&&(c==0))cout<<"INFINITE DE SOLUTIONS\n";

ÏϧÏ÷¹else if((a==0)&&(b==0)&&(c!=0))cout<<"PAS DE SOLUTIONS\n";

ÏϧÏ÷¹else if((a==0)&&(b!=0))cout<<"UNE SOLUTION: X= "<<-c/b<<"\n"; ÏϧÏöélse //cas général

Ïϧϸ§{_// delta : variable “brouillon”

Ïϧϸ¨¹¹Ïfloat delta = b*b-4*a*c;  // déclarée localement

Ïϧϸ¨¹¹Ïcout<<"DELTA="<<delta<<"\n";

Ïϧϸ¾¹³¹if(delta<0)cout<<"DELTA NEGATIF PAS DE SOLUTION\n";

ÏϧϸÏÏöélse

ÏϧϸÏϸ§{

ÏϧϸÏϸ¾¹³¹if(delta==0)cout<<"DELTA NUL, UNE SOLUTION X="<<-b/2/a<<"\n"; ÏϧϸÏϸÏÏöélse

ÏϧϸÏϸÏϸ§{

ÏϧϸÏϸÏϸ¨¹¹Ïx1= (-b+sqrt(delta))/2/a;

ÏϧϸÏϸÏϸ¨¹¹Ïx2= (-b-sqrt(delta))/2/a;

ÏϧϸÏϸÏϸ¨¹¹Ïcout<<"DELTA POSITIF DEUX SOLUTIONS\n";

ÏϧϸÏϸÏϸ¾¹¹Ïcout<<"X1= "<<x1<<"  X2= "<<x2<<"\n";

ÏϧϸÏϸÏÏÈÏ}

ÏϧϸÏÏÈÏ}

ÏϧÏÈÏ} 

Ïϧ

Ïϧ// calculs terminés 

ÏϨ¹¹Ïcout<<"\n\nPOUR CONTINUER FRAPPER UNE TOUCHE";

ÏϨ¹¹Ïgetch();

ÏÏ©}

Exercice III_6:

#include

#include

ÏÞßàvoid main() Ïϧ{

ÏϨ¹¹Ïint i = 0;

Ïϧ// le type float pour générer des temporisations suffisamment longues

ÏϨ¹¹Ïfloat x, tempo=5000000.0;

ÏϨ¹¹Ïcout<<"POUR SORTIR DE CE PROGRAMME FRAPPER UNE TOUCHE ...\n"; ÏϨ¹¹®do

ÏϧÏÏ5{

ÏϧÏÏ7¹¹Ïcout<<"i = "<< i <<"  i*i="<< i*i <<"\n";

ÏϧÏÏ7¹¹#for(x=tempo; x>0; x--);

ÏϧÏÏ7¹¹Ïi++;

ÏϧÏÏ5}

ÏϧÏÏòwhile(kbhit()==0); // on peut aussi écrire while(!kbhit());

ÏÏ©}

COURS et TP DE LANGAGE C++

Chapitre 4

Utilisation d’une bibliothèque

Joëlle MAILLEFERT

IUT de CACHAN

Département GEII 2

CHAPITRE 4

UTILISATION D'UNE BIBLIOTHEQUE

Ce petit chapitre vise à expliquer comment se servir d'une bibliothèque de fonctions. On prendra quelques exemples dans la bibliothèque de BORLAND C++.

NOTION DE PROTOTYPE

Les fichiers de type ".h" (conio.h, dos.h iostream.h etc...), appelés fichiers d'en tête  contiennent la définition des prototypes  des fonctions utilisées dans le programme. Le prototype précise la syntaxe de la fonction: son nom, le type des paramètres éventuels à passer, le type de l’expression - la valeur retournée au programme (void si aucun paramètre retourné).

Grâce aux lignes "#include",le compilateur lit les fichiers de type ".h" et vérifie que la syntaxe de l'appel à la fonction est correcte.

FONCTIONS NE RENVOYANT RIEN AU PROGRAMME

Ce sont les fonctions de type void.

Exemple: clrscr

fonction

Efface l'écran de la fenêtre dos.

prototype

void clrscr();

prototype dans

conio.h  et donc bibliothèque à charger.

Une fonction ne renvoyant rien (de type void) s'écrit telle que. C’est une action représentée par une instruction. Ici pas de passage d'arguments.

ex:      clrscr();                      // efface l'écran          cout >>"BONJOUR\n";

            cout>>"AU REVOIR\n";

FONCTIONS RENVOYANT UNE VALEUR AU PROGRAMME

Ce sont les fonctions de type autre que void. Elles renvoient au programme une valeur (expression) dont le type est précisé dans la documentation.

Exemple: kbhit

fonction

Teste une éventuelle frappe au clavier

prototype

int kbhit();

prototype dans

conio.h  et don


183