Université de Nice-Sophia Antipolis POLYTECH

(1)

Université de Nice-Sophia Antipolis POLYTECH

ELEC4 2017–2018

Examen de Programmation C++

Durée : 1h

Aucun document autorisé

Mobiles interdits Nom : Prénom :

Afin de gagner de la place mémoire, on définit des matrices de réels dites creuses qui ne mémorisent que des valeurs différentes de 0. Une matrice creuse M×Nsera représentée par :

— un nombre de lignes ;

— un nombre de colonnes ;

— une suite de triplets. Chaque triplet contient l’indicelde la ligne, l’indice cde la colonne et la valeur réelle double (non nulle) de la case(l, c)de la matrice creuse.

Par exemple, la matrice creuse3×4suivante :



 0 0 0 0 0 0 0 6.5

−3.2 0 0 0





est représentée par





 3 4

(2,0,−3.2)(1,3,6.5)

I1. Écrivez la classetripletpour représenter un triplet comme défini précédem- ment. Vous définirez son constructeur, ses accesseurs et ses mutateurs.

#i f n d e f TRIPLET_HPP

#d e f i n e TRIPLET_HPP

#i n c l u d e <cassert >

/*

* La classe triplet représente la valeur d ’une matrice creuse de

* réels . Elle contient la valeur du réel et ses coordonnées ( lignes ,

* colonnes ) dans la matrice .

*

* @author Vincent Granet ( vg@unice . fr )

*/

c l a s s triplet { p r i v a t e:

i n t l , c; //

double valeur ; p u b l i c:

1

// constructeur

triplet (c o n s t i n t i , c o n s t i n t j , c o n s t double v) : l(i), c(j) , valeur (v) { assert (v =!0); } // accesseurs

double getValeur () c o n s t { r e t u r n t h i s-> valeur ; } i n t getLigne () c o n s t { r e t u r n t h i s->l; } i n t getColonne () c o n s t { r e t u r n t h i s->c; } // mutateurs

v oi d setLigne (c o n s t i n t l) { t h i s->l = l ; } v oi d setColonne (c o n s t i n t c) { t h i s->c = c; } /* Antécédent : v !=0 */

v oi d setValeur (c o n s t double v) { assert (v !=0);

t h i s-> valeur = v;

} };

#e n d i f

. . . . On considère que la classe génériquenoeud<T>, donnée en annexe, està votre dispositionpour représenter la suite de triplets.

I 2. Écrivez la classeMatriceCreuseavec :

1.troisvariables membres privéesnbLignesetnbColonnesde type int et lesElements, uneliste linéairede nœuds qui contient les triplets ; 2. un constructeur àdeuxparamètres pour initialiser les 3 variables membres ; 3. la fonctiongetValeurqui renvoie le réel (double) de coordonnées(l, c)

dans la matrice creuse courante.letcsont paramètres de la fonction.

4. la surcharge de l’opérateur<<pour écrire dans unostreamla matrice creuse courante. Par exemple, la matrice creuse précédente sera écrite :

0 0 0 0

0 0 0 6.5

−3.2 0 0 0

#i f n d e f MATRICECREUSE_HPP

#d e f i n e MATRICECREUSE_HPP

#i n c l u d e <iostream >

#i n c l u d e " noeud . hpp "

#i n c l u d e " triplet . hpp "

/*

* La classe MatriceCreuse représente des matrices creuses , i.e. des

* matrices dont la majorité des valeurs sont nulles . Seules les

* valeurs non nulles son mémorisées .

*

*/

2

(2)

c l a s s MatriceCreuse { p r o t e c t e d:

i n t nbLignes ; i n t nbColonnes ;

noeud < triplet > * lesElements ; p u b l i c:

// constructeur

MatriceCreuse (c o n s t i n t l , c o n s t i n t c) : nbLignes (l), nbColonnes (c), lesElements ( nullptr ) {

assert (l >0 && c >0);

}

// antécédent : l>=0 et l<nbLignes et c>=0 et c<nbColonnes

// rôle : renvoie le réel de coordonnées (l,c) dans la matrice courante c o n s t double getValeur (c o n s t i n t l , c o n s t i n t c) c o n s t; // surcharge de l’opérateur de sortie « pour écrire la matrice

// creuse p sur l’ostream f

f r i e n d std :: ostream &o p e r a t o r< <( std :: ostream &f , c o n s t MatriceCreuse &m );

};

#e n d i f

#i n c l u d e " MatriceCreuse . hpp "

// Antécédent : l>=0 et l<nbLignes et c>=0 et c<nbColonnes

// Rôle : renvoie le réel de coordonnées (l,c) dans la matrice courante

c o n s t double MatriceCreuse :: getValeur (c o n s t i n t l , c o n s t i n t c) c o n s t { assert (l >=0 && l < nbLignes && c >=0 && c < nbColonnes );

// chercher dans la liste l’élément de coordonnées (l,c) noeud < triplet > *p = lesElements ;

w h i l e (p != nullptr ) { triplet t = p -> getElement ();

i f (t. getLigne () == l && t. getColonne () == c) // trouvé !

r e t u r n t. getValeur ();

// else passer au triplet suivant p = p -> getSuivant ();

}

// élément non trouvé r e t u r n 0.0;

}

// surcharge de l’opérateur de sortie « pour écrire la matrice // creuse p sur l’ostream f

std :: ostream &o p e r a t o r< <( std :: ostream &f , c o n s t MatriceCreuse &m) { f o r (i n t i =0; i <m. nbLignes ; i ++) {

f o r (i n t j =0; j <m. nbColonnes ; j ++) f << m. getValeur (i ,j) << " ";

//

f << std :: endl ; }

3

r e t u r n f;

}

. . . .

Annexe

#i f n d e f NOEUD_HPP

#d e f i n e NOEUD_HPP /*

* la classe générique noeud représente un maillon d ’une liste chaînée

*

*/

template <typename T >

c l a s s noeud { p r i v a t e:

T elt ;

noeud <T > * suivant ; p u b l i c:

// constructeur

noeud (T e , noeud <T > *s = nullptr ) : elt (e), suivant (s) {}

// accesseurs

c o n s t T & getElement () c o n s t { r e t u r n t h i s-> elt ;

}

noeud <T > * getSuivant () c o n s t { r e t u r n t h i s-> suivant ; }

// mutateurs

v oi d setSuivant ( noeud <T > *s) { t h i s-> suivant = s;

}

v oi d setElement (c o n s t T &x) { t h i s-> elt = x;

} };

#e n d i f

4