MIGS1 - Module algorithmique et programmation C/C++

TD 7 - Héritage
Exercice 1 :
1. Faire une classe vect permettant de manipuler des vecteurs dynamiques
d’entiers (c’est-à-dire dont la taille peut être fixée au cours de l’exécution)
dont la déclaration se présente ainsi :

class vect
{int nelem; // nombre d’elements
int * adr; //adresse zone dynamique contenant les elements
public :
vect(int); //constructeur prcisant le nombre d’lments
~vect(); destructeur
int & operator[](int); //acces a un element par son indice
}

2. Créer une classe vectb, dérivée de vect, permettant de manipuler des

vecteurs dynamiques, dans lesquels on peut fixer les bornes des indices,
lesquelles seront fournies au constructeur de vectb. La classe vect ap-
paraı̂tra ainsi comme un cas particulier de vectb (la borne inférieure étant
0). On ne se préoccupera pas, ici, des problèmes éventuellement posés par
la recopie ou l’affectation d’objets de type vectb.
3. Faire un programme principal qui permette de tester que tout marche
bien.
4. Comment aurions-nous pu définir operator[] dans vectb si le membre adr
avait été d’accès protected au lieu de private?

Exercice 2 :

1. Quels seront les résultats fournis par ce programme :

#include <iostream>
using namespace std;
class A
{int n;
float x;
public :
A(int p=2)
{
n=p;x=1;
cout << " construction objet A :" << n << " "<< x <<"\n";
}
};
class B
{int n;
float y;

1
 public :
B(float v=0.0)
{
n=1;y=v;
cout << "construction objet B : " << n <<" "<< y <<"\n";
}
};
class C : public B, public A
{int n;
int p;
public :
C(int n1=1,int n2=2, intn3=3, float v=0.0) : A(n1), B(v)
{
n=n3;p=n1+n2;
cout << " construction objet C :" << n << " " << p << "\n";
}
};
int main()
{C c1;
C c2(10,11,12,5.0);
return 0;
}

2. Même question si l’on remplace l’en-tête du constructeur de C par :

C(int n1=1, int n2=2, int n3=3, float v=0.0) : B(v)

3. Même question si l’on remplace l’en-tête du constructeur de C par :

C(int n1=1, int n2=2, int n3=3, float v=0.0)

Exercice 3 :
Quels seront les résultats fournis par ce programme :
#include <iostream>
using namespace std;
class A
{int na;
public :
A(int nn=1)
{na=nn; cout << "construction objet A" << na << "\n" ;
}
};
class B : public A
{float xb;
public :
B(float xx=0.0)
{ xb=xx; cout << " construction objet B" << xb <<"\n";
}

2
};
class C : public A
{int nc;
public :
C(int nn = 2) : A (2*nn+1)
{ nc=nn;
cout << "construction objet C" << nc << "\n";
}
class D : public B, public C
{int nd;
public :
D(int n1, int n2, float x) : C(n1), B(x)
{ nd=n2;
cout << "construction objet D" << nd << "\n";
}
};
int main()
{ D d (10, 20, 5.0);
return 0;
}

Exercice 4 :
0- Commencer par implémenter une classe liste permettant de manipuler des
listes chaı̂nées d’entiers. La déclaration de la classe liste se présentera ainsi :
struct element // structure d’un element de la liste
{element * suivant; //pointeur sur l’element suivant
int contenu;
};
class liste
{
element * debut; // pointeur sur le premier element
element * courant; // pointeur sur l’element courant
public :
liste(); // constructeur
~liste(); //destructeur
void ajoute(int); // ajoute un element en debut de liste
element * premier();
element * prochain();
int fini();
};

Pour ”explorer” la liste, on a prévu trois méthodes publiques:

1. premier qui donne à courant l’adresse du premier élément de la liste et
renvoie son adresse.

2. prochain qui renvoie l’adresse de courant et donne à courant l’adresse de

l’élément d’après. Des appels successifs de prochain permettent de par-
courir la liste.

3
 3. fini qui permet de savoir si courant a atteint la fin de la liste.
1- On souhaite maintenant créer une classe liste permettant de manipuler des
listes chaı̂nées dans lesquelles la nature de l’information associée à chaque noeud
de la liste n’est pas connue (par la classe). La déclaration de la classe liste se
présentera ainsi :
struct element
{element * suivant;
void * contenu; //pointeur sur un objet quelconque
};
class liste
{element * debut; // pointeur sur le premier element
element * courant; // pointeur sur l’element courant
public :
liste(); // constructeur
~liste(); //destructeur
void ajoute(void * p); // ajoute un nouvel element en debut de liste de contenu p
element * premier();
element * prochain();
int fini();
};

2- Soit la classe point suivante :

class point
{int x, y;
public :
point(int abs=0, int ord=0){x=abs;y=ord;}
void affiche(){cout << "Coordonnees : " << x <<" "<<y "\n";}
};

En vous aidant de l’en-tête ci-dessous, créer une classe listepoints dérivée de

liste permettant de manipuler des listes chaı̂nées de points. On devra pouvoir
ajouter un point en début de liste et disposer d’une fonction membre affiche
affichant les informations associées à chacun des points de la liste de points.
class listepoints : public liste
{
public :
void affiche();
listepoints(){};
}

3- Ecrire un programme d’essai.

4- Refaire une liste chaı̂née de points en utilisant cette fois-ci un patron de classe
de liste.