AP6 & INF1 C++ & Génie Logiciel Introduction IUT... · Apprendre un langage orienté objet : C++...

37
AP6 & INF1 C++ & Génie Logiciel Introduction Welcome !

Transcript of AP6 & INF1 C++ & Génie Logiciel Introduction IUT... · Apprendre un langage orienté objet : C++...

AP6 & INF1

C++ & Génie Logiciel

Introduction

Welcome !

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 - 4

Réponse : parce que !

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 »

GL / C++

Chapitre 1

C++ : les premiers « + »

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)

GL / C++

Chapitre 2

Lecture et écriture sur le terminal

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