Pour aller plus loin [225-264]

Pour aller plus loin : sommaire

Pour aller plus loin 1

Généricité

Fonction générique
Classe générique
Syntaxe de la généricité
Héritage et généricité
Amitié et généricité
Exemples : tableau générique, file générique

int Min(int a, int b) {

return (a<b)?a:b ;

}
Ne marche que pour le type int
--> autant de fonctions à écrire que de types à gérer !!!

const int Dim=100;

class TabInt {

   int tab[Dim];

public:

   int& operator[](int);

   voidsort(); ...

};
Une classe à écrire pour chaque type d'élément contenu !!!

--> Généricité : possibilité de paramétrer les définitions de fonction ou de classe

Pour aller plus loin 2

Fonction générique (1)

template <class T> // template = gabarit

T Min(T a,T b) {

return (a<b)?a:b ;

}

int main() {

int i=1, j=3, k; float x=1.4, y=2.5, z;

myClass a, b, c;

...

k = Min(i,j);

z = Min(x,y);

c = Min(a,b); // OK

// (si operator<(myClass,myClass) défini)

}

Le type effectif (introduit par class) peut être une classe définie par l'utilisateur ou un type prédéfini.
Plusieurs ``types formels'' différents sont possibles dans le paramétrage.
Chaque type formel doit apparaître au moins une fois dans la liste des arguments de la fonction.

Pour aller plus loin 3

Fonction générique (2)

L'association du type effectif et du type formel est faite à chaque appel selon la 1ère occurence dans la signature de chaque type formel.
Si un type formel est présent plusieurs fois, tous les types effectifs correspondants doivent être en adéquation (plus ou moins exacte selon le compilateur) --> se reporter à une documentation digne de ce nom !!!.
Possibilité de spécialiser une fonction générique par une définition particulière pour un ou plusieurs types particuliers.

char* Min (char *s1, char *s2) {

return( (strcmp(s1,s2)<0) ? s1 : s2);

}
La définition non-générique de la fonction est ``prioritaire'' par rapport aux définitions génériques.

Pour aller plus loin 4

Classe générique (1)

Déclaration :

template <class type>

class Tableau {

   type tab[Dim];

public :

   type& operator[](int);

   void sort(void);

...

}; // --> Tableau<type>nouveau type.
Définition : chaque définition d'une fonction membre de la classe doit être précédée de la déclaration de généricité.

template <class type>

void Tableau<type>::sort(void) { ...}
Utilisation :

Tableau<int> soldes ;

Tableau<compte>comptes ;

Pour aller plus loin 5

Classe générique (2)

Possibilité de spécialiser une classe générique, ou une méthode de classe générique, par une définition particulière pour un ou plusieurs types particuliers.

// Spécialisation de méthode

Tableau<char*>::method(args) { ...}

// Spécialisation de classe

class Tableau<String> {

// redéfinition complète... };
Des paramètres formels de la définition générique peuvent représenter des constantes (précédées de leur type) :

// définition

template <class type, int size>

class Tableau {

type tab[size];

... };

// utilisation

const int defSize=10;

Tableau<float, 10*defSize> tab ;

Pour aller plus loin 6

Syntaxe de la généricité

Le mot clé template doit débuter la définition et la déclaration de toute fonction ou classe générique.
Le mot clé template doit être suivi d'une liste non vide de paramètres formels englobés dans '<' et '>'. Les paramètres sont séparés par des virgules.
Dans le cas d'une fonction, les paramètres formels sont des types précédés du mot clé class.
Dans le cas d'une classe, les paramètres formels peuvent être soit un type (précédé de class), soit une expression constante (précédée de son type)
Les définitions de fonction ou de classe génériques ne peuvent avoir lieu qu'au niveau global : pas de définitions imbriquées de généricité.

Pour aller plus loin 7

Héritage et généricité

On peut dériver une classe générique à partir d'une classe générique.

template <class T>

class Pile : private Liste<T>{ ... };
--> la classe dérivée hérite de la propriété de généricité.

Pour aller plus loin 8

Relations d'amitiés génériques (1)

Une fonction ou classe non générique amie d'une classe générique est amie de TOUTES les instanciations de la classe.

template <class T> class A {

friend class AutreClasse;

// ...

};
Une classe ou une fonction générique amie d'une classe générique avec le même paramètrage, définit une relation d'amitié entre instanciations correspondantes.

template <class T> class A {

friend class B<T>;

// ...

};

Pour aller plus loin 9

Relations d'amitiés génériques (2)

une classe ou une fonction générique amie d'une classe générique sans le même paramètrage, définit une relation d'amitié entre n'importe quelles instanciations.

template <class Type> class A {

   template <class T>

      friend class B;

   template <class T>

      friend void C<T>::meth();

   // ...

};

Pour aller plus loin 10

Exemple : Tableau générique

#ifndef _tableau_h

#define _tableau_h

template < class T> class tableau {

public:

// construteurs

tableau(unsigned int nbElts);

tableau(unsigned int nbElts, T valInit);

tableau(const tableau<T>&);

//destructeur

~tableau();

// operateurs

virtual T& operator[] (unsigned int ind) const;

// fonctions

unsigned int longueur(void) const;

unsigned int setnbElts(unsigned int nbElts);

// Modif. _nbElts + valeur initiale

unsigned int setnbElts(unsigned int nbElts,

T& valInit);

protected:

T * data;

unsigned int _nbElts;

};

#endif

Pour aller plus loin 11

Constructeurs de la classe Tableau

#include <assert.h>

#include "tableau.h"

template<class T>

tableau<T>::tableau(unsigned int nbElts)

: _nbElts(nbElts)

{ data = new T[_nbElts];

assert(data!=0); }

template<class T>

tableau<T>::tableau(unsigned int nbElts,

T valinit) : _nbElts(nbElts)

{ data = new T[_nbElts];

assert(data!=0);

for (int i=0; i<_nbElts; i++)

data[i]=valinit; }

template<class T>

tableau<T>::tableau(const tableau<T> & source)

: _nbElts(source._nbElts)

{ data = new T[_nbElts];

assert(data!=0);

for (int i=0; i<_nbElts; i++)

data[i]=source.data[i]; }

Pour aller plus loin 12

Destructeur

template <class T> tableau<T>::~tableau()

{ delete [] data;

data = 0;

_nbElts = 0; }

Opérateurs

template<class T>

T & tableau<T>::operator[] (unsigned int ind) const

{ assert((ind<_nbElts) && (0<=ind));

return(data[ind]); }

template<class T>

unsigned int

tableau<T>::setnbElts(unsigned int nbElts)

{ T * newData = new T[nbElts];

assert(newData!=0);

int fin = min(nbElts,_nbElts);

for(int i=0;i<fin;i++)

newData[i]=data[i];

delete [] data;

_nbElts = nbElts; data = newData;

return_nbElts; }

Pour aller plus loin 13

Opérateurs (suite)

template<class T>

unsigned int

tableau<T>::setnbElts(unsigned int nbElts,

T & valinit)

{ T * newData = new T[nbElts];

assert(newData!=0);

int fin = min(nbElts,_nbElts);

for(int i=0;i<fin;i++)

newData[i]=data[i];

_nbElts = nbElts;

for(int i=fin;i<_nbElts;i++)

newData[i]=valinit;

delete [] data;

data = newData;

return _nbElts; }

template<class T>

unsigned int tableau<T>::longueur(void) const

{ return_nbElts; }

Pour aller plus loin 14

Exemple : File générique

#ifndef file_h

#define file_h

#include <iostream.h>

// Déclaration avant définition

template <class Type> class File;

// Element d'une file

template <class Type>

class EltFile {

public:

friend class File<Type>;

EltFile( const Type &t ) : elemt( t )

{ next = 0; }

private:

Type elemt;

EltFile *next;

};

template <class Type>

ostream&

operator<<(ostream&,EltFile<Type>&);

Pour aller plus loin 15

File (suite)

template <class Type>

class File {

public:

File() { tete = queue = 0; }

~File();

void enleve();

Type valeur();

void ajoute( const Type& );

int vide() { return tete==0 ? TRUE : FALSE; }

private:

EltFile<Type> *tete;

EltFile<Type> *queue;

};

template <class Type>

ostream&

operator<<(ostream&,File<Type>&);

#endif

Pour aller plus loin 16

Assertions Exceptions

Pour aller plus loin 17

Correction et validité

Un logiciel est correct s'il ne présente pas d'erreur de syntaxe et s'exécute sans erreur.
La validité d'un logiciel est une notion sémantique : elle exprime le fait qu'une mise en oeuvre satisfait la spécification et les contraintes d'exécution.
Actuellement la validité d'un logiciel ne peut être prouvée par analyse statique du programme.
--> tests dynamiques lors de l'exécution
--> utilisation :
- des assertions,
- et des exceptions.

Pour aller plus loin 18

Assertions et programmation par objets

Rôle des assertions :
1. contribuer à réaliser du logiciel valide,
2. aider à la documentation,
3. permettre le déboguage,
1. et 2. ¾® outils méthodologiques
3. ¾® rôle des assertions à l'exécution
Les assertions permettent de mettre en évidence dans l'implémentation le type abstrait de donnée, et de tester la conformité du code à ce type abstrait.
- expressions des pré-conditions et des post-conditions,
- expressions des invariants de classe.

Pour aller plus loin 19

Expression des assertions

Fonction assert définie dans ``assert.h''

void assert(á expression ñ) ;
Le paramètre est interprété comme une expression booléenne :
- si elle est true, rien ne se passe,
- si elle est false,
  Assertion failed: expression, file nom_fichier, line numero

Pour aller plus loin 20

(Pré-/Post-)condition

Pré-condition : condition devant être vérifiée avant l'exécution des instructions d'une fonction.

void pile::depiler(void) {

   // pré-condition

   assert(!vide());

   // ...

}
Post-condition : condition devant être vérifiée après l'exécution des instructions d'une fonction.

void pile::empiler(int element) {

   // ...

   // post-condition

   assert(sommet() == element);

}

Pour aller plus loin 21

Invariant

Un invariant de classe est une propriété vérifiée en permanence (sauf éventuellement pendant la phase transitoire correspondant à l'exécution de la méthode) par toute instance de la classe.

template <class type> class pile {

protected:

int taille, i; type *rep;

int invariant(void) const;

public:

void empiler(type element);

... };

template <class type>

int pile<type>::invariant(void) const {

return( (rep!=0) && (taille>=0)

&& (i<=taille) && (i>=0) ); }

template <class type>

void pile<type>::empiler(type element) {

...

rep[i++] = element;

assert(invariant());

}

Pour aller plus loin 22

Suspension de vérification

Les assertions sont prévues pour n'être vérifiées que pendant la phase de debug (le temps de calcul des assertions peut être prohibitif en phase d'exploitation) :
--> compilation avec -DNDEBUG, les assertions sont ignorées.

Ne mettre aucune instruction indispensable au sein d'une assertion,
La robustesse n'est pas améliorée par les assertions.

Pour aller plus loin 23

Exception

Une exception est une condition anormale, ou un cas particulier rencontré pendant l'exécution.
Ex :
- tentative d'accès en dehors des bornes d'un tableau,
- échec de l'allocation mémoire,
- ...
actions possibles en situation d'exception :
1. essayer de traiter la situation localement,
2. renvoyer un code d'erreur au module appelant,
3. afficher un message d'erreur et arrêter l'exécution (par un exit),

Pour aller plus loin 24

Exemple (1)

// Sans les exceptions :

action1 ;

if erreur1 { ...}

else {

action2 ;

if erreur2 { ...}

else {

action3 ;

if erreur3 { ...}

else { ...

Pour aller plus loin 25

Expression des exceptions

Signaler (ou soulever) une exception : throw
Syntaxiquement, une exception est une instance de n'importe quel type (int, char *, classe définie par l'utilisateur, ...). Exemples :

int * pt = new int[taille];

if (pt==0)

throw "Echec allocation";

enum IndErrs { IndxTooSmall, IndxTooBig };

if (i<0)

throw IndxTooSmall;

class outRangeVal { ...

public:

outRangeVal(const char *, int);

reparer();

... };

// ...

if (tab[i]>Tmax)

throwoutRangeVal("Too big value",i); }

Pour aller plus loin 26

Gestion des exceptions

Gérant d'exception : try { ... } catch

try { // Expression du code

// générateur potentiel d'exceptions

alloue();

initialise();

process();

}

// traitement des exceptions

catch(char * str){

cerr << str << "\n";

exit(-1);

}

catch(outRangeVal& exc){

exc.reparer();

}

le gestionnaire d'erreur activé est le catch de même type que l'exception (ou "compatible").

Pour aller plus loin 27

Propagation des exceptions

types compatibles : catch(void * v) récupère toutes les exceptions de type pointeur ; catch(className c) récupère les exceptions instances de toute classe dérivée.
si pas de catch du bon type, propagation de l'exception dans le try { ...} catch de niveau supérieur s'il existe, sinon arrêt du programme.
possibilité de forcer la propagation d'exception : ajout de throw à la fin du bloc catch.

Pour aller plus loin 28

Exemple (2)

// Solution avec les exceptions :

class exc1;

class exc2;

class exc3;

try {

// module de détection

action1 ;

if erreur1 throw exc1( ...) ;

action2 ;

if erreur2 throw exc2( ...) ;

action3 ;

if erreur3 throw exc3( ...) ;

}

// module de traitement

catch (exc1& e) { ...} ;

catch (exc2& e) { ...} ;

catch (exc3& e) { ...} ;

Pour aller plus loin 29

Exemple : Pile

Pile.h

#ifndef _pile_h

#define _pile_h

template <class type>

class pile {

protected:

int taille;

int i;

type *rep;

int invariant() const;

public:

pile(int i=10);

~pile();

void empiler(type element);

void depiler();

const type& sommet() const;

int vide() const;

int pleine() const;

};

#endif

Pour aller plus loin 30

Pile.cpp

#include <assert.h>

#include "pile.h"

template <class type>

pile<type>::pile(int t):i(0),taille(t) {

rep = new type[taille];

assert(invariant()); }

template <class type>

pile<type>::~pile(void) {

delete [] rep; }

template <class type>

int pile<type>::vide(void) const {

return i==0; }

template <class type>

int pile<type>::pleine(void) const {

return i==taille; }

template<class type>

void pile<type>::depiler(void) {

if (vide())

throw "impossible: pile vide";

i--;

assert(invariant()); }

Pour aller plus loin 31

Pile.cpp (suite)

template <class type>

void pile<type>::empiler(type element) {

if (pleine())

throw "impossible: pile pleine";

rep[i++] = element;

assert(invariant());

// post-condition

assert(sommet() ==element); }

template <class type>

const type& pile<type>::sommet(void) const {

if (vide())

throw "impossible: pile vide";

return rep[i-1]; }

template <class type>

int pile<type>::invariant(void) const {

int v = (rep != 0);

v &&= (taille >= 0);

v &&= (i <= taille);

v &&= (i>=0);

returnv; }

Pour aller plus loin 32

Programme principal

#include <iostream.h>

#include <stdlib.h>

#include "pile.h"

const line = 80;

int main(void)

{

pile<int> p1;

char rep[line];

{

cout << "Entrer une commande (edsq) : ";

cin >> rep[0];

try

{

switch(rep[0]) {

case 'e' :

cout << "Entrer une valeur : ";

cin >> rep;

p1.empiler(atoi(rep));

break;

case 'd' :

p1.depiler();

break;

Pour aller plus loin 33

Programme principal (suite)

case 's' :

cout << "sommet : " ;

cout << p1.sommet() << "\n";

break;

case 'q' :

break;

default :

throw "Attention a la syntaxe";

break;

}

catch (const char* msg)

{

cerr << msg << endl;

cerr << "Commande ignoree\n";

}

} while (rep[0] != 'q');

return 0;

}

Pour aller plus loin 34

Bibliothèque standard C ISO

ou ``bibliothèque d'exécution'' ou ``runtime library''

Collection standard de fonctions, types et macros.
Étend largement les possibilités du langage.
Collection séparée en une douzaine de familles.
Chaque famille correspond à un fichier d'en-tête où sont rassemblées les déclarations des types, macros et fonctions disponibles pour le programmeur.
Pages de manuel disponibles en-ligne
(section 3 du man Unix)
Fichiers d'en-tête accessibles sous : /usr/include
Version compilée archivée comme : /lib/libc.a

Pour aller plus loin 35

Fichiers d'en-tête standards

<assert.h> : diagnostic

<ctype.h> : tests sur les caractères

<float.h> : constantes d'implantation des types flottants

<limits.h> : constantes d'implantation des types scalaires

<math.h> : fonctions mathématiques

<setjmp.h> : les goto non locaux

<signal.h> : manipulation des exceptions

<stdarg.h> : liste d'arguments de nombre variable

<stdio.h> : entrées-sorties

<stdlib.h> : fonctions utilitaires

<string.h> : manipulation de chaînes de caractères

<time.h> : accès à la date et à l'heure

Pour aller plus loin 36

<string.h>

- Longueur d'une chaîne :
int strlen(char *s)

- Comparaison de chaînes :
int strcmp(char *s1, char *s2)
int strncmp(char *s1,char *s2,int n)

- Concaténation de chaînes :
char *strcat(char *dest, char *orig)
char *strncat(char *dest,char *orig,int n)

- Copie de chaînes :
char *strcpy(char *dest, char *orig)
char *strncpy(char *dest,char *orig,int n)

- ...

Pour aller plus loin 37

<stdlib.h>

Comporte de nombreuses fonctions absolument essentielles :

Gestion mémoire dynamique :
malloc, calloc, free, etc.
Conversions nombre ® chaîne :
atof, atoi, atol, etc.
Génération de nombres pseudo-aléatoires :
rand, srand, etc.
Lien avec le système d'exploitation :
exit, abort, getenv, system, etc.
...

Pour aller plus loin 38

<ctype.h>

Fonctions de test sur les caractères :

int isalpha(int c)
int isdigit(int c)
int islower(int c)
int isupper(int c)
int iscntrl(int c)
int isspace(int c)
int ispunct(int c)
...

Valeur de retour : 1 si vrai, 0 si faux.

Pour aller plus loin 39

<math.h>

sin(x) cos(x) tan(x)
asin(x) acos(x) atan(x) atan2(x)
sinh(x) cosh(x) tanh(x)
log(x) log10(x)
exp(x) pow(x,y) sqrt(x)
fmod(x, y) modf(x, *ip)
ceil(x) floor(x) fabs(x)
ldexp(x, n) frexp(x, int *exp)

Remarques :
- arguments: double (sauf n: integer);
- type de retour: double (y compris ceil et floor);
- angles en radians.

Pour aller plus loin 40

<time.h>

Donne accès à la date et à l'heure.

Exemple :
struct tm *stm; long lg; int day; lg=time(0); stm=localtime(&lg);/* day reçoit le numéro du jour dans le mois. */day=stm.tm_mday; fprintf(stdout,"%s\n",asctime(stm));

Nota-bene : pour ``dormir'' n secondes :

sleep(durée-en-secondes);