C++ - Partie (1)

Dr. Ing. Aniss MOUMEN

Module Programmation 2
EHTP - 2017

Module Programmation 2 - EHTP 2017 1

 Langage C | Langage C++
POSSIBLE
• Commentaire :
Il existe deux façons d'insérer des commentaires en C++
La façon habituelle du langage C reste valide :
/* Ceci est un commentaire qui peut porter sur plusieurs lignes */
C++ propose une façon supplémentaire
// Commentaire jusqu'à la fin de ligne
• Input/output
En C : Scanf …. /printf…
En C++ : cin >> …..ou cout << …..
….
• Déclaration des variables locales :
En C : avant les instructions
En C ++ : avant l’utilisation
• Déclaration des objets globaux :
En C : in t i ;
En C++ : extern int i;
PAS TOUJOURS POSSIBLE
Module Programmation 2 - EHTP 2017 2
 Structure générale d’un programme C++
La structure très générale d’un programme C++ est la suivante :
#include <des_librairies_utiles>
...
using namespace std; // on y reviendra
(déclaration d’objets globaux) [à éviter]
déclarations de fonctions utiles [recommandé]
int main() //ou int main(int argc, char **argv)
{
corps du
programme principal [si possible assez court]
}

Module Programmation 2 - EHTP 2017 3

 Variables

Module Programmation 2 - EHTP 2017 4

 Variables

Module Programmation 2 - EHTP 2017 5

Opérations

Module Programmation 2 - EHTP 2017 6

Entrée - Sortie

Module Programmation 2 - EHTP 2017 7

Entrée - Sortie

Module Programmation 2 - EHTP 2017 8

Entrée - Sortie

Module Programmation 2 - EHTP 2017 9

Structure de contrôle

Module Programmation 2 - EHTP 2017 10

Structure de contrôle

Module Programmation 2 - EHTP 2017 11

Structure de contrôle

Module Programmation 2 - EHTP 2017 12

Opérateurs de Comparaison

Module Programmation 2 - EHTP 2017 13

Opérateurs de comparaison

Module Programmation 2 - EHTP 2017 14

Opérateur de comparaison

Module Programmation 2 - EHTP 2017 15

 Choix

Module Programmation 2 - EHTP 2017 16

Boucles & itérations

Module Programmation 2 - EHTP 2017 17

Break & Continue

Module Programmation 2 - EHTP 2017 18

 Pratique

Module Programmation 2 - EHTP 2017 19

 IDE C++ - NetBeans

Installation de Cygwin Base Directory

gcc-core: C compiler
gcc-g++: C++ compiler
gdb: The GNU Debugger
make: the GNU version of the 'make' utility
Module Programmation 2 - EHTP 2017 20
Exemple de programme en C++

Module Programmation 2 - EHTP 2017 21

 Travaux dirigés 0
Exercice 0 Exercice 5
Ecrire un algorithme qui échange la valeur de deux variables. Ecrire un algorithme qui demande un nombre compris entre 10 et
Exemple, si a = 2 et b = 5, le programme donnera a = 5 et b = 20, jusqu’à ce que la réponse convienne. En cas de réponse
2. supérieure à 20, on fera apparaitre un message : Plus petit ! ,
Exercice 1 et inversement, Plus grand ! Si le nombre est inférieur à 10.
Ecrire un algorithme qui demande un nombre à l’utilisateur, puis qui Exercice 6
calcule et affiche le carre de ce nombre. Ecrire un algorithme qui demande un nombre de d´epart, et qui
Exercice 2 calcule la
Ecrire un algorithme qui lit le prix HT d’un article, le nombre somme des entiers jusqu’`a ce nombre.
d’articles et le taux de TVA, et qui fournit le prix total TTC Exercice 7
correspondant. Faire en sorte que des libelles apparaissent Ecrire un algorithme qui demande un nombre de départ, et qui
clairement. calcule sa factorielle.
Exercice 3 Exercice 8
Ecrire un algorithme qui demande deux nombres à l’utilisateur et écrivez un algorithme permettant, à l’utilisateur de saisir les notes
l’informe ensuite si leur produit est négatif ou positif (on laisse d’une classe. L’algorithme, une fois la saisie terminée, renvoie
de coté le cas o`u le produit est nul). Attention toutefois : on le nombre de ces notes supérieures à la moyenne de la classe.
ne doit pas calculer le produit des deux nombres.
Exercice 4
Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur.
Ensuite, il l’informe de sa catégorie :
”Poussin” de 6 à 7 ans
”Pupille” de 8 à9 ans
”Minime” de 10 à 11 ans
”Cadet” après 12 ans

Module Programmation 2 - EHTP 2017 22

 Tableau
• Un tableau est une collection indicée de variables de même
type.
• Déclaration d’un tableau :
type nom_tableau[nombre_elements]
float t[10] : 10 élément de type float
1ére position est : t[0]
iéme valeur d’un tableau est le t[i]
• Affectation :
t[2] = 5
• Opération : t[3]++ , --t[i]
IMPOSSIBLE D’AFFECTER UN TABLEAU DANS UN AUTRE : t1 = t2

Module Programmation 2 - EHTP 2017 23

 Tableau
• Dimension d’un tableau : le nombre des éléments
const int N = 50 ;
int t[N] ;
• Tableau à multiple indice
int t[3][4]
• Initialisation :
int tab[5] = { 10, 20, 5, 0, 3 } ;
int tab[] = { 10, 20, 5, 0, 3 } ;
(le compilateur détermine la taille)
int tab [3] [4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 } ;
Module Programmation 2 - EHTP 2017 24
 Tableau
On retiendra les trois règles suivantes :
• Les tableaux peuvent être passés en
paramètres dans les fonctions,
• les tableaux ne peuvent être renvoyés (avec
return) comme résultats de fonctions,
• l’affectation entre tableaux est interdite.

Module Programmation 2 - EHTP 2017 25

 Chaîne de caractère
• En C++, une chaîne de caractères n’est rien d’autre
qu’un tableau de caractères, avec un caractère nul
’\0’ marquant la fin de la chaîne.
• Exemples de déclarations :
char nom[20], prenom[20]; // 19 caractères utiles
char adresse[3][40]; // trois lignes de 39 caractères
utiles
char turlu[10] = {’t’, ’u’, ’t’, ’u’, ’\0’}; // ou : char
turlu[10] = "tutu";
Module Programmation 2 - EHTP 2017 26
 Chaine de caractère
• strlen(s) (dans string.h) : donne la longueur de la chaînes

• strcpy(dest, source) (dans string.h) : recopie la chaîne source dans dest

• strcmp(s1,s2) (dans string.h) : compare les chaînes s1 et s2 : renvoie une

valeur < 0, nulle ou > 0 selon que s1 est inférieure, égale ou supérieure à
s2 pour l’ordre alphabétique.

• gets(s) (dans stdio.h) : lit une chaîne de caractères tapée au clavier,

jusqu’au premier retour à la ligne (inclus) ; les caractères lus sont rangés
dans la chaîne s, sauf le retour à la ligne qui y est remplacé par ’\0’.

• tolower() (dans ctype.h) convertit une lettre majuscule en minuscule

• toupper() (dans ctype.h) convertit une lettre minuscule en majuscule
Module Programmation 2 - EHTP 2017 27
 Pointeur
• Un pointeur est une variable qui
contient l’adresse d’une autre variable.
• La déclaration d’un pointeur est :
<type> *<nom>;

• Par exemple : int *p;

La variable p est alors un pointeur sur un
int ; la variable entière dont p contient
l’adresse est dite pointée par p et se note
*p.
Module Programmation 2 - EHTP 2017 28
 Pointeur
• int *p, *q, n;
• n = -16;
• *p = 101;
• *q = n + *p; // donne à *q la valeur 85

Module Programmation 2 - EHTP 2017 29

 Pointeur
• Pointeur sur une variable :
int a;
int* pA;
pA = &a; // l'adresse de a est stockée dans pA

Exemple :
• lecture de la valeur de a
cout << "A vaut " << a ;
cout << "A vaut " << *pA ;
• lecture de l'adresse de a
cout << "L'adresse de A est " << &a ;
cout << "L'adresse de A est " << pA ;
• Le pointeur pA peut par la suite pointer l'adresse d'une autre variable.
Module Programmation 2 - EHTP 2017 30
 Pointeur
#include <iostream>
using namespace std;
int main()
{
int a, b, c;
int *x, *y;
a = 98;
x = &a;
c = *x + 5;
y = &b;
*y = a + 10;
cout << "La variable b vaut : " << b << endl;
cout << "La variable c vaut : " << c << endl;
return 0;
}
Module Programmation 2 - EHTP 2017 31
 Pointeur
Exemple :
char* ptr="Pointeur";
// ptr pointe le premier caractère de la chaîne de
caractères
cout << ptr << endl; // affiche "Pointeur"
ptr = ptr+3;
cout << ptr << endl; // affiche "nteur"
cout << ++ptr << endl; // affiche "teur"
cout << --ptr << endl; // affiche "nteur"
Module Programmation 2 - EHTP 2017 32
 Références
• Une référence peut être vue comme un alias
d'une variable
• Déclaration :
type& identificateur = variable ;

La variable identificateur est une référence vers

la variable variable. La variable variable doit
être de type type.
Module Programmation 2 - EHTP 2017 33
 Références
#include <iostream>
using namespace std;
int main()
{
int a = 98, b = 78, c;
int &x = a;
c = x + 5; // équivaut à : c = a + 5;
int &y = b;
y = a + 10; // équivaut à : b = a + 10;
cout << "La variable b vaut : " << b << endl;
cout << "La variable c vaut : " << c << endl;
return 0;
}

Module Programmation 2 - EHTP 2017 34

 Allocation dynamique de la mémoire

• Déclaration d’un pointeur :

int *p; // p : pointeur sur int
• Allocation de la mémoire
p = new int;
• Manipulation
*p = 12; // ou tout autre traitement...
• Libération de la mémoire
delete p;
Module Programmation 2 - EHTP 2017 35
 Tableau dynamique
• Un tableau dynamique est un tableau dont la
taille peux varier -> allocation dynamique de la
mémoire.

• On utilise « new » et « delete »

Module Programmation 2 - EHTP 2017 36

 Tableau dynamique
• Déclaration :
int *T;
• Allocation :
T = new int [n];
• Traitement
delete [] T;

Module Programmation 2 - EHTP 2017 37

 Tableau dynamique
#include <iostream> for (int i=0; i < nLignes; i++)
using std::cout; for (int j=0; j < nColonnes; j++)
using std::cin; t[i][j] = i*j;
int **t; /* Affichage */
int nColonnes; for (int i=0; i < nLignes; i++)
int nLignes; { for (int j=0; j < nColonnes; j++)
void Free_Tab(); // Libérer l'espace mémoire; cout << t[i][j] << " "; cout << endl; }
int main() Free_Tab();
{ system("pause>nul");
cout << "Nombre de colonnes : "; return 0;
cin >> nColonnes; }
cout << "Nombre de lignes : "; void Free_Tab(){
cin >> nLignes; for (int i=0; i < nLignes; i++)
/* Allocation dynamique */ delete[] t[i];
t = new int* [ nLignes ]; delete[] t;
for (int i=0; i < nLignes; i++) }
t[i] = new int[ nColonnes ];
/* Initialisation */

Module Programmation 2 - EHTP 2017 38

 Fonctions

Module Programmation 2 - EHTP 2017 39

 Fonctions

Module Programmation 2 - EHTP 2017 40

 Fonctions

Module Programmation 2 - EHTP 2017 41

 Fonctions

Module Programmation 2 - EHTP 2017 42

 Fonction
• Passage d’un pointeur en paramètre
Prototype :
void passagePointeur(int *);
Définition :
Void passagePointeur(int * ptr)
{ /* ... */ }
Appel :
passagePointeur (&a);
Module Programmation 2 - EHTP 2017 43
 Fonction
Exemple : {
#include <iostream> int num = 100;
using std::cout; cout << "\n*ptr : " << *ptr; // Affiche la valeur
void passagePointeur(int *); pointée
void passageValeur(int); *ptr = 9; // Change la valeur pointée;
int main() ptr = &num; // <-- modification de l'adresse
{ ignorée par la fonction appelante
int a = 5; }
int b = 7; void passageValeur(int val)
cout << "a : " << a << "\nb : " << b; { cout << "\nval : " << val;
passageValeur (a); // Appel de la fonction en val = 12;
passant la variable a par valeur // <-- modification de la valeur ignorée par la
passagePointeur (&b); // Appel de la fonction en fonction appelante
passant l'adresse de la variable b par }
pointeur
cout << "\na : " << a << "\nb : " << b;
return 0;
}
void passagePointeur(int * ptr)
Module Programmation 2 - EHTP 2017 44
 Fonction
• Passage d’une référence en paramètre
void incrementer(int& value)
{
value++;
}
void test()
{
int a = 5;
cout << "a = " << a << endl; // a = 5
incrementer(a);
cout << "a = " << a << endl; // a = 6
}

Module Programmation 2 - EHTP 2017 45

 Structure
• Les structures permettent de regrouper plusieurs
variables dans une même entité
• Syntaxe :
struct identificateur
{
// liste des différents champs constituant notre structure
// utilise la même syntaxe que la déclaration de
variables
} [variables];

Module Programmation 2 - EHTP 2017 46

 Structure
• Exemple avec un variable : • Exemple :
struct Point struct Point
{ {
double x; double x;
double y; double y;
}; };
• L’accès : • L’accès :
Point A; Point* pA;
A.x = 2 pA->x = 2 (ou (*pA).x = 2)
A.y = 3 pA->y = 3 (ou (*pA).y = 3)

Module Programmation 2 - EHTP 2017 47