AP6 & INF1 C++ & Génie Logiciel Introduction IUT... · Apprendre un langage orienté objet : C++...
Transcript of AP6 & INF1 C++ & Génie Logiciel Introduction IUT... · Apprendre un langage orienté objet : C++...
AP6 cours 1 - 2
Objectifs du cours
� Apprendre un langage orienté objet : C++
� Découvrir, par la pratique, les notions fondamentales de la Programmation Orientée Objet (POO)… en complément du cours de Conception de Systèmes à Objets (CSO).
� Sensibiliser aux nécessaires exigences du « Génie Logiciel » (GL)
� Découvrir quelques outils du GL
� Illustrer tout ce qui précède par un projet de programmation « conséquent » : un interprèteur…
� … et découvrir par la même occasion quelques notions de compilation des langages
AP6 cours 1 - 3
Question : "Mais M'sieur...."
Pourquoi on fait encore du C++, c'est de l'abuse !... Le Java c'est extra...
... Le C# c'est balèze...
... Le PHP c'est la panacée...
... Le python c'est trop bon...
... Le Lisp c'est pas triste...(mais, Hervé Blanchon, qu'est-ce que tu fais là ???)
... L'assembleur c'est le bonheur...
... Le Visual Basic c'est top chic...
... Ada, je ne veux que ça...
... Y'a un langage développé par moi qui est sympa...
... etc...
AP6 cours 1 - 5
Modalités� 1h30 de Cours/TD
� 3h de TP (2 séances de 1h30)
� 8 semaines consacrées à la découverte de la POO et des outils du GL (AP-6)
� 5 semaines consacrées au projet (CINF-1)
� Evaluation :
� AP-6 : 2 examens sur papier
� CINF-1: Evaluation du projet : dossier + démonstration sur machines
AP6 cours 1 - 6
C++ Introduction� Conçu en 1982 par Bjarne Stroustrup
(AT&T Bell Laboratories, le berceau d’Unix et C)
� Objectif : ajouter au langage C le concept de
classes tel qu’il avait été introduit par le langage
Simula
� Intérêt : bénéficier des avantages de la
programmation orientée objet tout en conservant
les performances du langage C et ses
bibliothèques nombreuses et variées
AP6 cours 1 - 7
Enjeux de la programmation et du GL
� La production d’un logiciel, considéré comme un
processus industriel (et non pas comme un « hobby »)
doit remplir les critères suivants :
� Exactitude (fonctionnement correspondant aux spécifications)
� Robustesse (vis-à-vis des conditions anormales)
� Evolutivité (facilité à ajouter de nouvelles fonctionnalités)
� Généricité, Réutilisabilité (possibilité de réutiliser des modules dans d’autres logiciels)
� Portabilité (aptitude à fonctionner sur différentes plateformes)
� Performances (temps d’exécution, ressources consommées)
AP6 cours 1 - 8
Programmation structurée � Le langage C, langage impératif, permet une
programmation structurée, selon l’équation de Wirth :
Programme = Algorithmes + Structures de Données
� Cette approche a permis d’augmenter exactitude et robustesse…
� … Mais n’a pas permis d’atteindre les objectifs souhaités
en termes d’évolutivité et de réutilisabilité
� Origine du problème : le découplage entre structures de
données et traitements qui oblige à « casser » un module dès que l’on remet en cause une structure de
données.
AP6 cours 1 - 9
Apports de la POO : objet� La notion d’objet autorise l’encapsulation des données
et des traitements sur ces données
Objet = Méthodes + Données
� Impose de manipuler les données via les méthodes
� Conséquence : l’objet est est uniquement caractérisé par
la spécification de ces méthodes… peu importe la structure des données
� On réalise ainsi une abstraction des données qui facilité l’évolutivité et la réutilisabilité
� Exemple : un objet « collection de données » qui peut
être implémenté sous forme de tableau dynamique ou de liste chaînée, avec des méthodes d’ajout, de
parcours, …
AP6 cours 1 - 10
Apports de la POO : classe� La notion de classe d’objets est une
généralisation de la notion de type déjà
rencontrée dans les langages impératifs
� Classe = description d’un ensemble d’objets
ayant les mêmes structures de données et
les mêmes méthodes
� Un objet est une instance de la classe à
laquelle il appartient
AP6 cours 1 - 11
Apports de la POO : héritage� L’héritage permet de construire une nouvelle
classe à partir d’une classe déjà existante.
� La nouvelle classe hérite de toutes les propriétés de la classe existante et lui en ajoute de nouvelles (on parle de spécialisation)
� La notion d’héritage facilite la réutilisabilité
� C++ permet l’héritage multiple : une nouvelle classe peut hériter de plusieursclasses existantes
AP6 cours 1 - 12
Spécificités de C++� Langage impératif auquel on a ajouté des
fonctionnalités objet
� Permet une transition en douceur de la
programmation structurée vers la
programmation objet
� N’impose pas une programmation objet
« pure et dure » comme Simula, Smalltalk ou
Java
AP6 cours 1 - 13
C++ et normes� C++ peut être vu comme le langage C ANSI
auquel :
� On a ajouté, mais aussi supprimé, quelques contraintes par rapport à la norme ANSI
� On a ajouté quelques spécificités « non objet »
� On a ajouté tout l’aspect « objet »
AP6 cours 1 - 15
Les premiers plus � Commentaires de fin de ligne� Déclarations dans les instructionsint main(){
// une déclarationint i;// une instructionscanf("%d", &i); // lire i// une nouvelle déclarationint j;scanf("%d", &j);
return 0;}
AP6 cours 1 - 16
Les premiers plus� Déclaration d'une variable de boucle for
int main()
{
int tab[10]={0,1,2,3,4,5,6};
for (int i=0; i<7; i++)
// i n'est visible que dans l'itération
printf("%d ", tab[i]);
printf("\n");
return 0;}
� L’initialisation des variables scalaires peut être faite par une expression quelconque
AP6 cours 1 - 17
Variable référence
� En C, pour accéder à l'adresse d'une variable, on utilise une variable adresse.
� En C++, on peut aussi utiliser une variable référence
int main()
{
int i=5,j=6;
int &k=i; // k référence i, est un alias de i
int &n; // incorrect :
// il manque la variable référencée
printf("k : %d\n", k); // affiche i càd 5
k=j; // équivalent à i=j
printf("i : %d\n", i); // affiche 6
return 0;
}
AP6 cours 1 - 18
Variable référence
� Une variable référence est une sorte de
variable adresse :
� plus simpe à utiliser syntaxiquement
� mais dont la variable référencée est toujours la même (on ne peut pas la changer).
AP6 cours 1 - 19
Passage de Paramètre par Référence
(résultat ou donnée-résultat)� C++ permet de réaliser des passages de
paramètres résultat ou donnée-résultat de manière plus élégante qu’en C grâce à la notion de paramètre référence.
� Exemple - considérons la déclaration d’article suivante :
struct produit {
char nom[30];
float prix;
};
AP6 cours 1 - 20
Fonction avec paramètre référence :bool recherche(
struct produit tab[], // tableau de produits (donnée)int n, // nombre d'éléments de tab (donnée) char nom_prod[], // nom du produit recherché (donnée) struct produit &p ) // p est un paramètre résultat
// p est une référence à une variable x
// recherche si tab contient un produit de nom nom_prod// si oui, range la 1ère occurrence dans x et retourne true// si non, retourne false
{int i;for (i=0; i<n && strcmp(tab[i].nom, nom_prod)!=0; i++)
{ // itération vide
}if (i<n) // on a trouvé : tab[i].nom==nom_prod
p=tab[i]; return i<n;
}
� Le paramètre p s'utilise comme la variable x qu’il référencera…� … donc on écrit p=tab[i]; pour effectuer en fait x=tab[i];
AP6 cours 1 - 21
Exemple d'utilisation de la fonction
int main(){
struct produit tab[10]= { {"aaa", 15},
{"bbb", 12},
{"ccc", 20} };
struct produit prod;
if (recherche(tab, 3, "bbb", prod))
// prod est la variable référencée par le paramètre p
// de la procédure recherche
printf("%s %5.2f\n", prod.nom, prod.prix);
return 0;
}
pas de "&"
devant prod !
AP6 cours 1 - 22
En C on aurait écrit :int recherche(
struct produit tab[], // tableau de produits
int n, // nombre d'éléments
char nom_prod[], // nom d'un produit
struct produit *p) // p : adresse d'une variable x
{
int i;
for (i=0; i<n && strcmp(tab[i].nom, nom_prod)!=0; i++)
{ // itération vide
}
if (i<n) *p = tab[i];
return i<n;
}� L'emploi d'un paramètre référence est donc
plus simple (les opérateurs * disparaissent)
AP6 cours 1 - 23
En C, on aurait appelé la fonction ainsi :
int main () {
struct produit tab[10]= { {"aaa", 15},
{"bbb", 12},
{"ccc", 20} };
struct produit prod;
if (recherche(tab, 3, "bbb", & prod ))
printf("%s %5.2f\n", prod.nom, prod.prix);
return 0;
}
AP6 cours 1 - 24
En résumé
void SOMME (int n1,
int n2,
int & resultat) {
resultat = n1 + n2;
}
int main() {
int res;
SOMME(2,3,res);
printf("Résultat 2+3 = %d\n",res);
return 0;
}
void SOMME (int n1,
int n2,
int * resultat) {
*resultat = n1 + n2;
}
int main() {
int res;
SOMME(2,3,&res);
printf("Résultat 2+3 = %d\n",res);
return 0;
}
C++C
AP6 cours 1 - 25
Valeurs par défaut de paramètres
int f1(int x, int y=4) // 4 : valeur par défaut de y
{
return x+y;
}
//----------------------------------------------------
int f2(int x=3, int y=4)
{
return x+y;
}
� Exemples corrects
AP6 cours 1 - 26
Valeurs par défaut de paramètres
int f3 (int x=3, int y)
// x ayant une valeur par défaut,
// les paramètres suivants
// (selon l'ordre de lecture gauche->droite)
// doivent aussi avoir une valeur par défaut
{
return x+y;
}
� Exemple incorrect
AP6 cours 1 - 27
Valeurs par défaut de paramètres� Exemples d'appels des fonctions corrects
int main()
{
int a;
a = f1(10, 23); // a = 33
a = f1(10); // a = 14
a = f2(10, 23); // a = 33
a = f2(10); // a = 14
a = f2(); // a = 7
return 0;
}
AP6 cours 1 - 28
Surcharge de fonctions et de procédures � Plusieurs fonctions ou procédures peuvent avoir le
même nom, à condition qu'elles aient :
� soit un nombre différent de paramètres
� soit aux moins un paramètre de type différent
� Le type du résultat ne compte pas pour différencier la procédure (3)
et la fonction (4)
void p(int i); // procédure (1)
void p(float i); // procédure (2)
// paramètre de type # (1)
void p(int i, int j); // procédure (3)
// nombre de paramètres # (1)
int p(int i, int j); // fonction (4)
// incorrect, 2 paramètres
// de même type que (3)
AP6 cours 1 - 30
Lecture et écriture sur le terminal� En C : bibliothèque stdio, utilisable en C++
� En C++ : bibliothèque iostream, orientée
objets (description fournie plus tard)
� 2 objets particuliers :
� cout pour écrire sur l'écran du terminal,
� cin pour lire sur le clavier du terminal.
AP6 cours 1 - 31
Objet stream� cin et cout sont des objets de la classe stream
� Un stream est un objet :� qui représente un support d'informations sur lequel on
peut lire ou bien écrire ou bien lire et écrire.
� qui possède toutes les méthodes pour lire ou écrire sur ce support.
� Un support d'informations peut être:� l'écran ou le clavier d'un terminal ,
� un fichier
� une zone de mémoire (chaîne de caractères).
� Le mot stream peut être traduit par flot (flux) dedonnées.
AP6 cours 1 - 32
Exemple d'utilisation de cout
Méthode (opérateur) <<
int main()
{
int code = 147;
char num_tel[] = "0476284528";
float prix = 12.5;
cout << code << num_tel << prix << endl;
}� L'opérateur << envoie une valeur de type prédéfini (int, short, float, char) sur un stream d'écriture
� L'opérateur endl envoie une fin de ligne
AP6 cours 1 - 33
Exemple d'utilisation de cin
Méthode (opérateur) >>
� L'opérateur >> extrait une valeur de type
prédéfini (int, short, float, char) d'un stream
de lecture.
int main()
{
int code;
char num_tel[11];
float prix;
cin >> code >> num_tel >> prix;
}
AP6 cours 1 - 34
Manipulateurs � Fonctions ou opérateurs qui permettent de
modifier le statut d'un stream, par exemple le format et la base de lecture ou d'écriture.
� Le statut d’un stream est défini par un mot d’état (une suite de bits). Ce mot est découpé en plusieurs champs, chaque champ étant composé d’un certain nombre de bits.
� Les manipulateurs permettent de modifier ces bits en utilisant la syntaxe d’une entrée ou d’une sortie, c’est-à-dire en utilisant les opérateurs >> ou <<
AP6 cours 1 - 35
saute les espacesEntréews
saute ou pas les espaces Entréeskipws/noskipws
définit la largeur d'affichage (gabarit)Entrée/Sortiesetw(int)
définit la précision des flottantsEntrée/Sortiesetprecision(int)
met à un les bites de formattage désignésEntrée/Sortiesetiosflags(long)
définit le caractère de remplissageEntrée/Sortiesetfill(int)
fixe la base de conversionEntrée/Sortiesetbase(int)
remet à zéro les bits de formattage désignésEntrée/Sortieresetiosflags(long)
conversion octaleEntrée/Sortieoct
conversion hexadécimaleEntrée/Sortiehex
conversion décimaleEntrée/Sortiedec
représentation des booléens (0/1 ou false/true)Entrée/Sortieboolalpha/noboolalpha
affichages en majusules/minusculesSortieuppercase/nouppercase
montre/cache le signe + devant les nombres positifsSortieshowpos/noshowpos
montre/cache le point décimalSortieshowpoint/noshowpoint
montre/cache la baseSortieshowbase/noshowbase
notation scientifique ou fixeSortiescientific/fixed
cadrage gauche, droite, remplissage après signe ou baseSortieleft/right/internal
vide le tamponSortieflush
insère une fin de chaîne (caractère '\0')Sortieends
insère un saut de ligne et vide le tamponSortieendl
ActionUtilisationManipulateur
AP6 cours 1 - 36
Exemple : manipulateurs en sortie#include <iostream>
#include <iomanip>
using namespace std; // indispensable depuis la norme ANSI ISO
int main()
{ // en commentaire, le résultat produit
cout << setprecision(3) << 110.55555 << endl;
// 110.556
cout << scientific << 110.5 << endl;
// 1.105e+02
cout << setw(10) << fixed << setfill((int)'-') << 110.5 << endl;
// -----110.5
cout << setfill((int)'*') << "abc" << endl;
// *******abc
return 0;
}
AP6 cours 1 - 37
Exercice pour se réveiller après l’été…� Ecrire un programme qui :
� lit une suite de 10 notes (des réels) au clavier et
les range dans un vecteur
� Appelle une procédure qui reçoit en paramètre
donnée le vecteur et calcule la moyenne de ce vecteur qui est renvoyée via un paramètre
référence
� affiche la moyenne calculée en « point fixe » avec 2 décimales sur un gabarit de 8 caractères