Université Ibn-Zohr

Ecole Nationale des Sciences Appliquées

Département Génie Informatique

Exercices corrigés
__________________________________
Programmation Orientée Objet
__________________________________

Matière : Programmation Orientée Objet

Module : Structure de données et programmation orienté objet
1ème année du cycle d’ingénieur
Filière : Finance et Ingénierie Décisionnelle

Prof : Abderrahmane ELYOUSFI

2021-2021
Exercice:1
1-Ecrire un programme en C++ qui permet de trié dans l'ordre croissant les éléments
d'un tableau des entiers à une dimension.
 Les valeurs du tableau sont saisies du clavier.
 Utiliser la méthode de bulle pour le tri (méthode de la propagation de la valeur
maximale).
Note: Implémenter l'algorithme en considérant que :
 La partie du tableau (à droite) où il n'y a pas eu de permutations est triée.
 Si aucune permutation n'a eu lieu, le tableau est trié.

Corrigé
#include<iostream>
Unsing namespace std;

int main()
{
const int M=20;
int T[M];
for(int i=0 ; i<M ; i++)
{
cout<<"Entrer la valeur de T["<<i<< "]=" ;
cin>>T[i] ;
cout<<"\n" ;
}
int k;
for(int i=M-1; i>0; i=k)
{
k=-1;
for(int j=0; j<i; j++)
{
if(*(T+j)>*(T+j+1))
{
tmp=*(T+j);
*(T+j)=*(T+j+1);
*(T+j+1)=tmp;
k=j;
}
}
}
for(int i=0 ; i<M ; i++)
{
cout<<T[i]<<"\t" ;
}
}//fin main()
Exercice:2
Le fichier du programme ci-dessous est enregistré sous le nom MyProg.cpp.

#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
int idx;
cout<< "le nombre d’arguments est:"<< argc;
for (idx = 0; idx < argc; idx++)
{
cout<<“argv[”<<idx<<“]=“<< *(*(argv+idx)+2)<<endl;
}
return 0;
}

Si j'exécute ce programme en mode commande de la façon suivante, donner le résultat

de l'exécution de ce programme:
MyProg.exe param1 param2 param3.
Corrigé
Le nombre d’arguments est: 4 argv[0]=P
argv[1]=r
argv[2]=r
argv[3]=r
Exercice:3
Soit M une constante de valeur 20.
Soient T1, T2 et T3 trois tableaux à une dimension avec M est la taille du tableau T1.
Les valeurs des éléments du tableau T1 sont saisies à partir du clavier.
Le tableau T2 contient les valeurs du tableau T1 et le nombre de répétition successive de
chaque valeur. On note que chaque valeur est suivie par son nombre de répétition
successive.
Le tableau T3 contient les valeurs du tableau T1 et le nombre de répétition de chaque
valeur dans le tableau. On note que chaque valeur est suivie par son nombre de
répétition.
Exemple:
T1 3 3 4 4 3 3 7 7 7 4 3 3 3 3

3 2 4 2 3 2 7 3 4 1 3 4
 T2

T3 3 8 4 3 7 3
Corrigé
#include<iostream>
using namespace std ;
int main()
{
const int M=5;
int i,j;
int k, l, m;
//reservation de l'espace memoire
int *T1=new int[2*M];
int *T2=new int[2*M];
int *T3=new int[2*M];

//la saisie des valeurs du tableau T1 à partir du clavier

for(i=0; i<M; i++)
{
cout<<"T1["<<i<<"]=";
cin>>*(T1+i);
cout<<endl;
}

//l'affichage des valeurs de T1

for(i=0; i<M;i++)
{
cout<<*(T1+i)<<"\t";
}
cout<<"\n";
i=0;
j=0;
l=1;

*(T2+j)=*(T1+i);
for(i=1; i<M; i++)
{
if(*(T1+i)==*(T2+j))
l++;
else
{
*(T2+j+1)=l;
 *(T2+j+2)=*(T1+i);
j=j+2;
l=1;
}
}

*(T2+j+1)=l;
for(int i=0; i<j+3;i++)
{
cout<<*(T2+i)<<"\t";
}
cout<<"\n";
i=0;
j=0;
l=1;

*(T3+j)=*(T1+i);
//Calcul du nombre de répétition pour le premier élément du tableau T1

for(i=1; i<M; i++)

{
if(*(T1+i)==*(T3+j))
{
l++;
}
}

*(T3+j+1)=l;
j=j+2;
l=0;
int m1;

for(i=0; i<M-1; i++)

{
if(*(T1+i)!=*(T1+i+1))
{
m1=0;

for(int k=0; k<j; k=k+2)

{
if(*(T1+i+1)==*(T1+k))
m1=1;
}
}
 if(m1==0)
{
*(T3+j)=*(T1+i+1);
for(int k=i+1; k<M; k++)
if(*(T3+j)==*(T1+k))
l++;

*(T3+j+1)=l;
j=j+2;
l=0;
m1=1;

for(int i=0; i<j+3;i++)

{
cout<<*(T3+i)<<"\t";
}
cout<<"\n";
}
Exercice:4
Soient T1 et T2 deux tableaux de deux dimensions de même taille 8x8. Ecrire un
programme en C++ qui lit les valeurs des éléments du premier tableau T1 à partir du
clavier et qui calcule les valeurs des éléments du deuxième tableau T2 par la formule
suivante:
( ) ( )
( ) ( ) ( )∑∑ ( ) ( ) ( )
√
avec, pour k= i ou j:

( ) {
⁄
√
Note:
Utiliser la réservation dynamique pour les deux tableaux.
Utiliser seulement la syntaxe des pointeurs.

Corrigé:

#include<iostream>
#include<cmath>

using namespace std;

int main()
{
const int N=8;
int i, j, x, y;
int **T1;
T1=new int*[N];
double **T2;
T2=new double*[N];

for(i=0; i<N; i++)

*(T1+i)=new int[N];

for(i=0; i<N; i++)

*(T2+i)=new double[N];

for(i=0; i<N; i++)

{
for(j=0; j<N; j++)
{
cout<<"T1["<<i<<"]["<<j<<"]=";
cin>>T1[i][j];
cout<<"\t";
 }
cout<<"\n";
}

for(i=0; i<N; i++)

{
for(j=0; j<N; j++)
{
cout<<T1[i][j];
cout<<"\t";
}
cout<<"\n";
}

for(i=0; i<N; i++){

for(j=0; j<N; j++){
*(*(T2+i)+j)=0;
for(int x=0; x<N; x++){
for(int y=0; y<N; y++){
*(*(T2+i)+j)=*(*(T1+x)+y)*cos(((2*x)+1*i*3.14)/16)*cos(((2*y+1*j*3.14)/16));
}
}

}
}

for(i=0; i<N; i++){

for(j=0; j<N; j++){
if((i==0)&&(j==0))
{
*(*(T2+i)+j)=(*(*(T2+i)+j)/sqrt(2));
}
else
if(((i==0)&&(j!=0))||((j==0)&&(i!=0)))
*(*(T2+i)+j)=(*(*(T2+i)+j)/2);
else
*(*(T2+i)+j)=(*(*(T2+i)+j)/(2*sqrt(2)));

}
}

for(i=0; i<N; i++)

{
 for(j=0; j<N; j++)
{
cout<<T2[i][j];
cout<<"\t";
}
cout<<"\n";
}

Exercice:5
Ecrire un programme en C++ qui calcule les éléments du triangle de Pascal.
 la i-éme ligne contient i colonnes,
 chaque ligne commence et se termine par un 1,
 l’élément à la ligne i, colonne j est la somme des éléments aux colonnes j et j-1 de la ligne
i-1.

Ecrire un programme en C++ qui inverse le triangle de Pascal.

1 1 8 28 56 70 56 28 8 1
1 7 21 35 35 21 7 1
1 1
1 2 1 6 15 20 15 6 1
1
1 3 3 1 1 5 10 10 5 1
1 4 6 4 1 1 4 6 4 1
1 5 10 10 5 1 1 3 3 1
1 2 1
6 15 20 15 6 1
1
1 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1 1
Triangle de Pascal Inverse du Triangle de Pascal

Note: Utiliser seulement la syntaxe des pointeurs.

Corrigé:

#include<iostream>
using namespace std;

int main()
{
const int N=12;
 int **T;
int i,j;
T=new int*[N];

for(i=0; i<N; i++)

{
T[i]=new int[i+1];
T[i][0]=1;
T[i][i]=1;

for(j=1;j<i;j++)
{
T[i][j]=T[i-1][j-1]+T[i-1][j];
}
}

for(i=0;i<N;i++)
{
for(j=0;j<=i;j++)
{
cout<<T[i][j]<<"\t";
}
cout<<endl;
}

int *tmp ;
for(int i=0 ; i<N/2 ; i++)
{
tmp=T[i]; T[i]=T[N-i-1]; T[N-i-1]=tmp;
}

for(i=0; i<N; i++)

{
for(j=N-1; j>N-i; j--)
{
cout<<T[i][j]<<"\t";
}
cout<<endl;
}
return 0;
}
Exercice:6
Soit M, L et C trois constantes de valeur respectivement 30, 20 et 10.
Soit T un tableau de trois dimensions de M matrices où chaque matrice contient L lignes
et C colonnes.
Ecrire un programme en C++ qui permet de réserver dynamiquement l’espace mémoire
pour le tableau T, de lire les valeurs des éléments de ce tableau à partir du clavier, et
d’afficher les valeurs de ce tableau. En plus, ajouter à ce programme un code en C++
qui permet de trier les matrices de ce tableau suivant l’ordre croissant de la somme des
valeurs des éléments de chaque matrice.
Note : Utiliser seulement la syntaxe des pointeurs.
Utiliser la méthode du bulle optimale pour le tri.
Corrigé:
#include<iostream>
using namespace std;
int main()
{
const int M=3, L=3, C=4;
int i, j, k;
int ***T=new int**[M];
int *S=new int[M];
for(i=0; i<M;i++){
*(T+i)=new int*[L];
for(j=0;j<L;j++)
{
*(*(T+i)+j)=new int[C];
for(k=0;k<C;k++){
cout<<"T["<<i<<"]["<<j<<"]["<<k<<"]=";
cin>>T[]i[j][k];
//T[i][j][k]=i+j+k;
}
}
}
for(i=0; i<M;i++){
for(j=0;j<L;j++)
{
for(k=0;k<C;k++){
cout<<T[i][j][k]<<"\t";
}
cout<<"\n";
}
cout<<"\n\n\n";
}
for(i=0;i<M;i++)
{
*(S+i)=0;
for(j=0; j<L; j++)
{
for(k=0; k<C; k++)
*(S+i)+=*(*(*(T+i)+j)+k);
}
}

int tmp; int **tmp1;

k=M-1;

for(i=M-1; i>0; i=k)

{
k=-1;
for(j=0; j<i; j++)
{
if(*(S+j)>*(S+j+1))
{
tmp=*(S+j);
*(S+j)=*(S+j+1);
*(S+j+1)=tmp;

tmp1=*(T+j);
*(T+j)=*(T+j+1);
*(T+j+1)=tmp1;

k=j;
}
}
}

for(i=0; i<M;i++){
for(j=0;j<L;j++)
{
for(k=0;k<C;k++){
cout<<T[i][j][k]<<"\t";
}
cout<<"\n";
}
cout<<"\n\n\n";
}
Exercice:7
Soit la classe matrice définie comme suit:

Class Matrice
{
public:
int nelm;
int **T;
public:
Matrice(int);
~Matrice();
Matrice(const Matrice &);
Matrice produit(Matrice);
};

Ecrire le programme en C++ qui permet de déclarer la classe Matrice et de définir ses
méthodes:
 Le constructeur usuel permet de:
 initialiser la variable nelm par la valeur de son argument.
 réserver dynamiquement un espace mémoire pour un tableau à deux dimensions
de taille nelm et l'adresse de ce tableau est affecté à T.

 Le destructeur permet de libérer l'espace de ce tableau T.

 Le constructeur de recopie permet de:
 créer dynamiquement un nouvel emplacement dans lequel il recopie les valeurs
correspondant à l’objet reçu en argument ;
 renseigner convenablement les membres données du nouvel objet (nelm = valeur
du membre nelm de l’objet reçu en argument, T = adresse du nouvel
emplacement).
 La méthode produit permet de calculer le produit scalaire de deux matrices.

Corrigé:
#include <iostream>
using namespace std ;

class Matrice
{
public:
int L;
int **T;
public:
Matrice(int);
~Matrice();
Matrice(const Matrice &);
};

Matrice::Matrice(int l)
{
L=l;
 T=new int*[L];
for(int i=0; i<L; i++)
{
T[i]=new int[L];
for(int j=0; j<L; j++)
T[i][j]=i+j;
}
cout <<"Appel au const usuel"<<endl;
}

Matrice::~Matrice()
{
for(int i=0; i<L; i++)
{
delete [] T[i];
}
delete [] T;
cout <<"Appel au destructeur"<<endl;
}

Matrice::Matrice(const Matrice & M1)

{

cout <<"Appel au const de recopie"<<endl;

L=M1.L;
T=new int*[L];

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

{
T[i]=new int[L];
for(int j=0; j<L; j++)
T[i][j]=M1.T[i][j];
}
}

int main()
{
Matrice M1(3) ;
Matrice M2(4) ;
Matrice M3=M1 ;

return 0;
}
Exercice:8

Si le code ci-dessous est exécutable, donner le résultat de l'exécution?

Si le code ci-dessous a un problème, donner une explication à ce problème?

#include <iostream>
using namespace std ;
// ************ classe point *********************
class A
{

public :
void f(int, int ) { cout<< "Appel F1:\n"; }
void g(char ) {cout<< "Appel F2:\n"; }

};
class B : protected A
{

public :
void f(int, int) { cout<< "Appel F3:\n"; }
};
// ************ programme d’essai ****************
int main()
{
int n=3 ; char c='A' ;
Bb;
b.f(n, n) ;
b.g(c) ;
return 0;
}

Corrigé
Ce code a un problème.
La dérivation protégée interdit l’utilisateur d’une classe dérivé d’accéder aux membres
publics de sa classe de base.
L’instruction b.g(c) n’est autorisée. Car la classe B dérivée de la classe A utilise la
dérivation protégée.
Exercice:9
Ecrire le prototype et la définition du constructeur usuel de la classe dérivée de ce
programme ci-dessous. Ce constructeur contient un instruction qui va initialiser la
variable coleur par son argument.

#include <iostream>
using namespace std ;
// ************ classe point *********************
class point
{
int x, y , z;
public :
point (int abs, int ord, int s)
{ x = abs ; y =ord ; z=s;
cout << "++ constr. point : " << x << " " << y << " "<<s <<"\n" ;
}
~point () // destructeur de point ("inline")
{ cout << "-- destr. point : " << x << " " << y <<" " <<s<<"\n" ;
}
};
// ************ classe pointcol ******************
class pointcol : public point
{
short couleur ;
public :
………………………………… ; // déclaration constructeur pointcol
~pointcol ()
{ cout << "-- dest. pointcol - couleur : " << couleur << "\n" ;
}
};
…………………………………………………………………………………………………..
. ………………………………………………………………………………………………….
.…………………………………………………………………………………………………..
.…………………………………………………………………………………………………..
// ************ programme d’essai ****************
int main()
{ pointcol a(3) ;
pointcol b(4, 5);
pointcol c;
pointcol * adr ;
adr = new pointcol ;
delete adr ;
return 0;
}
 Corrigé:

#include <iostream>
using namespace std ;
// ************ classe point *********************
class point
{
int x, y , z;
public :
point (int abs, int ord, int s)
{ x = abs ; y =ord ; z=s;
cout << "++ constr. point : " << x << " " << y << " "<<s <<"\n" ;
}
~point () // destructeur de point ("inline")
{ cout << "-- destr. point : " << x << " " << y <<" " <<s<<"\n" ;
}
};
// ************ classe pointcol ******************
class pointcol : public point
{
short couleur ;
public :
pointcol( int =0, int =0, int=0, short=0); // déclaration constructeur pointcol
~pointcol ()
{ cout << "-- dest. pointcol - couleur : " << couleur << "\n" ;
}
};
…………………………………………………………………………………………………..
. ………………………………………………………………………………………………….
pointcol( int a, int b, int c, short d):point(a, b, c)
{
Couleur=d;
}
// ************ programme d’essai ****************
int main()
{ pointcol a(3) ;
pointcol b(4, 5);
pointcol c;
pointcol * adr ;
adr = new pointcol ;
delete adr ;
return 0;
}
Exercice:10
Soit la classe matrice définie comme suit:
Donner le résultat de l’exécution du programme ci-dessous et une interprétation à de
résultat.

#include<iostream>
using namespace std;
class vecteur;
class matrice{
int c ;
int l ;
int **t;
public:
matrice(int=4, int=4);
~matrice();
matrice(const matrice &); //constructeur de recopie
friend void produit(matrice,vecteur);
};

class vecteur{
int *t;
int n;
public :
vecteur(int);
~vecteur();
vecteur(const vecteur &); //constructeur de recopie
friend void produit(matrice,vecteur);
};

matrice::matrice(int a,int b){

if(!(a>0 && b>0))
{a=4; b=4;}
l=a;
c=b;
t=new int*[l];
for(int i=0;i<l;i++)
t[i]=new int[c];
for(int i=0;i<l;i++){
for(int j=0;j<c;j++){
t[i][j]=i+j;
}
}

cout<<"appel de constructeur usuel de matrice:"<<l<<" "<<c<<"\n";

}

matrice::matrice(const matrice & m)

{
l=m.l;
c=m.c;
t=new int*[l];
for(int i=0;i<l;i++){
t[i]=new int[c];
}
for(int i=0;i<l;i++){
for(int j=0;j<c;j++){
t[i][j]=m.t[i][j];
}
}
cout<<"appel de constructeur de recopie de matrice: "<<l<<" "<<c<<"\n";
}

matrice::~matrice(){

cout<<"appel de destructeur de matrice : "<<l<<" "<<c<<"\n";

}

vecteur::vecteur(const vecteur &k){

n=k.n;
t=new int[n];
for(int i=0;i<n;i++){
t[i]=k.t[i];
}
cout<<" appel de constructeur de recopie de vecteur: "<<n<<"\n";

}
vecteur::vecteur(int d){
if(d>0){
n=d;
}
t=new int[n];
for(int i=0;i<n;i++){
t[i]= i+1;
}
cout<<"appel de constructeur usuel de vecteur :"<<n<<"\n";

}
vecteur::~vecteur(){

cout<<"appel de destructeur de vecteur :"<<n<<"\n";

}
void produit (matrice m, vecteur v){
if(v.n!=m.l)
{
cout<<"produit impossible\n";
}
else{
vecteur vr(m.c);
for(int i=0;i<m.c;i++)
{
vr.t[i]=0;
for(int j=0;j<v.n;j++){
vr.t[i]+=v.t[j]*m.t[j][i];
}
}
for(int i=0;i<m.c;i++){
cout<<vr.t[i]<<"\n " ;
}
}
}

int main(){
matrice m4(3,0);
matrice m5=m4;
matrice m1(3,2);
vecteur v1(3);
produit(m1,v1);
return 0;
}
Corrigé:
appel de constructeur usuel de matrice:4 4
appel de constructeur de recopie de matrice: 4 4
appel de constructeur usuel de matrice:3 2
appel de constructeur usuel de vecteur :3
appel de constructeur de recopie de vecteur: 3
appel de constructeur de recopie de matrice: 3 2
appel de constructeur usuel de vecteur :2
8
14
appel de destructeur de vecteur :2
appel de destructeur de matrice : 3 2
appel de destructeur de vecteur :3
appel de destructeur de vecteur :3
appel de destructeur de matrice : 3 2
appel de destructeur de matrice : 4 4
appel de destructeur de matrice : 4 4

Exercice:11
#include <iostream>
using namespace std ;
// ************ classe point *********************
class point
{ int x, y ;
public :
point (int abs=0, int ord=0)
{ cout << "++ constr. point : " << abs << " " << ord << "\n" ;
x = abs ; y =ord ; }
void affiche(int n){cout<<"point :"<<n<<endl ;}
~point ()
{ cout << "-- destr. point : " << x << " " << y << "\n" ; }
}; // ************ classe pointcol ******************
class pointcol : public point
{ short couleur ;
public :
pointcol (int, int, short) ;
~pointcol () { cout << "-- dest. pointcol - couleur : " << couleur << "\n" ; }
void affiche(float m){cout<<"pointcol :"<<m<<endl ;}
};
pointcol::pointcol (int abs=0, int ord=0, short cl=1) : point (abs, ord)
{ cout << "++ constr. pointcol : " << abs << " " << ord << " " << cl << "\n" ;
couleur = cl ;
} // ************ programme d’essai ****************
int main()
{ int k=8 ;
pointcol a(10,15,3) ;
pointcol b (2,3) ;
pointcol c (12) ;
pointcol d;
d.affiche(k) ;
pointcol * adr ;
adr = new pointcol (12,25) ;
delete adr ;
return 0;
}
Corrigé:

++ constr. point : 10 15
++ constr. pointcol : 10 15 3
++ constr. point : 2 3
++ constr. pointcol : 2 3 1
++ constr. point : 12 0
++ constr. pointcol : 12 0 1
++ constr. point : 0 0
++ constr. pointcol : 0 0 1
pointcol :8
++ constr. point : 12 25
++ constr. pointcol : 12 25 1
-- dest. pointcol - couleur : 1
-- destr. point : 12 25
-- dest. pointcol - couleur : 1
-- destr. point : 0 0
-- dest. pointcol - couleur : 1
-- destr. point : 12 0
-- dest. pointcol - couleur : 1
-- destr. point : 2 3
-- dest. pointcol - couleur : 3
-- destr. point : 10 15

Exercice:12

Soit la classe matrice définie comme suit:

class Matrice
{
public:
int L;
int **T;
public:
Matrice(int);
~Matrice();
Matrice(const Matrice &);
};

Ecrire le programme en C++ qui permet de déclarer la classe Matrice et de définir ses
méthodes:
Le constructeur usuel permet de:
initialiser la variable L par la valeur de son argument.
réserver dynamiquement un espace mémoire pour un tableau à deux dimensions de
taille LxL et l'adresse de ce tableau est affecté à T.

Le destructeur permet de libérer l'espace de ce tableau T.

Le constructeur de recopie permet de:
créer dynamiquement un nouvel emplacement dans lequel il recopie les valeurs
correspondant à l’objet reçu en argument ;
renseigner convenablement les membres données du nouvel objet (L = valeur du
membre L de l’objet reçu en argument, T = adresse du nouvel mplacement).

Corrigé:
#include <iostream>
using namespace std ;

class Matrice
{
public:
int L;
int **T;
public:
Matrice(int);
~Matrice();
Matrice(const Matrice &);
};

Matrice::Matrice(int l)
{
L=l;
T=new int*[L];
for(int i=0; i<L; i++)
{
T[i]=new int[L];
for(int j=0; j<L; j++)
T[i][j]=i+j;
}
cout <<"Appel au const usuel"<<endl;
}

Matrice::~Matrice()
{
for(int i=0; i<L; i++)
{
delete [] T[i];
 }
delete [] T;
cout <<"Appel au destructeur"<<endl;
}

Matrice::Matrice(const Matrice & M1)

{

cout <<"Appel au const de recopie"<<endl;

L=M1.L;
T=new int*[L];

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

{
T[i]=new int[L];
for(int j=0; j<L; j++)
T[i][j]=M1.T[i][j];
}
}

int main()
{
Matrice M1(3) ;
Matrice M2(4) ;
Matrice M3=M1 ;

return 0;
}

Exercice:13
Soit la classe point défini comme suit :
// ************ classe point *********************
class point
{
int x, y ;
public :
point (int abs, int ord)
{
cout << "++ constr. point : " << abs << " " << ord << "\n" ;
x = abs ; y =ord ;
}
~point ()
{
 cout << "-- destr. point : " << x << " " << y << "\n" ;
}
};

Soit la classe Poincol une classe dérivée de la classe point (dérivation publique)

La classe pointcol contient :

Deux variables (int col1 et int col2)
Un constructeur usuel permettant d’initialiser les variables x, y, col1 et col2 par les
valeurs de ses arguments.
Une fonction CalculeD() permettant de calculer la distance d’un point.

Ecrire un programme en C++ qui contient la classe point, la classe poincol avec la
définition de ses méthodes et la fonction main. Dans la fonction main crée un objet de la
classe poincol et calculer sa distance.
Note : Le statut de x et y est toujours privé.
L’ajout d’une autre fonction n’est pas accepté.
Corrigé:

#include <iostream>
#include<Cmath>
using namespace std;
class pointcol;

// ************ classe point *********************

class point
{
int x, y ;
public :
point (int abs, int ord)
{
cout << "++ constr. point : " << abs << " " << ord << "\n" ;
x = abs ; y =ord ;
}
~point ()
{
cout << "-- destr. point : " << x << " " << y << "\n" ;
}

friend class pointcol;

};
class pointcol:public point
{
int col1, col2;
public:
pointcol(int a, int b, int c, int d):point(a,b)
{
col1=c;
col2=d;
}
void calcul3D()
{
double Ds=sqrt(x*x+y*y);
cout<<"Distance="<<Ds<<endl;
}
};

int main()
{
pointcol pc (2, 4, 1, 3);
pc.calcul3D();

Exercice:14
Si le code ci-dessous est exécutable, donner le résultat de l'exécution?
Si le code ci-dessous a un problème, donner une explication à ce problème?

#include <iostream>
using namespace std ;
// ************ classe point *********************
class A
{ public :
void f(int, int ) { cout<< "Appel F1:\n"; }
void g(char ) {cout<< "Appel F2:\n"; }
};
class B : protected A
{ public :
void f(int, int) { cout<< "Appel F3:\n"; }
};
// ************ programme d’essai ****************
int main()
{
int n=3 ; char c='A' ;
Bb;
 b.f(n, n) ;
b.g(c) ;
return 0;
}

Corrigé
Ce code a un problème.
La dérivation protégée interdit l’utilisateur d’une classe dérivé d’accéder aux membres
publics de sa classe de base.
L’instruction b.g(c) n’est autorisée. Car la classe B dérivée de la classe A utilise la
dérivation protégée.

Exercice:15
Ecrire le prototype et la définition du constructeur usuel de la classe dérivée de ce
programme ci-dessous. Ce constructeur contient un instruction qui va initialiser la
variable coleur par son argument.

#include <iostream>
using namespace std ;
// ************ classe point *********************
class point
{
int x, y , z;
public :
point (int abs, int ord, int s)
{ x = abs ; y =ord ; z=s;
cout << "++ constr. point : " << x << " " << y << " "<<s <<"\n" ;
}
~point () // destructeur de point ("inline")
{ cout << "-- destr. point : " << x << " " << y <<" " <<s<<"\n" ;
}
};
// ************ classe pointcol ******************
class pointcol : public point
{
short couleur ;
public :
………………………………… ; // déclaration constructeur pointcol
~pointcol ()
{ cout << "-- dest. pointcol - couleur : " << couleur << "\n" ;
}
};
…………………………………………………………………………………………………..
. ………………………………………………………………………………………………….
.…………………………………………………………………………………………………..
.…………………………………………………………………………………………………..
…………………………………………………………………………………………………...
// ************ programme d’essai ****************
int main()
{ pointcol a(3) ;
pointcol b(4, 5);
pointcol c;
pointcol * adr ;
adr = new pointcol ;
delete adr ;
return 0;
}
Corrigé:

#include <iostream>
using namespace std ;
// ************ classe point *********************
class point
{
int x, y , z;
public :
point (int abs, int ord, int s)
{ x = abs ; y =ord ; z=s;
cout << "++ constr. point : " << x << " " << y << " "<<s <<"\n" ;
}
~point () // destructeur de point ("inline")
{ cout << "-- destr. point : " << x << " " << y <<" " <<s<<"\n" ;
}
};
// ************ classe pointcol ******************
class pointcol : public point
{
short couleur ;
public :
pointcol( int =0, int =0, int=0, short=0); // déclaration constructeur pointcol
~pointcol ()
{ cout << "-- dest. pointcol - couleur : " << couleur << "\n" ;
}
};
…………………………………………………………………………………………………..
. ………………………………………………………………………………………………….
pointcol( int a, int b, int c, short d):point(a, b, c)
{
Couleur=d;
}
// ************ programme d’essai ****************
int main()
{ pointcol a(3) ;
pointcol b(4, 5);
pointcol c;
pointcol * adr ;
adr = new pointcol ;
delete adr ;
return 0;
}

Exercice:16
Soit la classe matrice définie comme suit:
Donner le résultat de l’exécution du programme ci-dessous et une interprétation à de
résultat.

#include<iostream>
using namespace std;
class vecteur;
class matrice{
int c ;
int l ;
int **t;
public:
matrice(int=4, int=4);
~matrice();
matrice(const matrice &); //constructeur de recopie
friend void produit(matrice,vecteur);
};

class vecteur{
int *t;
int n;
public :
vecteur(int);
~vecteur();
vecteur(const vecteur &); //constructeur de recopie
friend void produit(matrice,vecteur);
};
matrice::matrice(int a,int b){
if(!(a>0 && b>0))
{a=4; b=4;}
l=a;
c=b;
t=new int*[l];
for(int i=0;i<l;i++)
t[i]=new int[c];
for(int i=0;i<l;i++){
for(int j=0;j<c;j++){
t[i][j]=i+j;
}
}

cout<<"appel de constructeur usuel de matrice:"<<l<<" "<<c<<"\n";

}

matrice::matrice(const matrice & m)

{
l=m.l;
c=m.c;
t=new int*[l];
for(int i=0;i<l;i++){
t[i]=new int[c];
}
for(int i=0;i<l;i++){
for(int j=0;j<c;j++){
t[i][j]=m.t[i][j];
}
}
cout<<"appel de constructeur de recopie de matrice: "<<l<<" "<<c<<"\n";
}

matrice::~matrice(){

cout<<"appel de destructeur de matrice : "<<l<<" "<<c<<"\n";

}

vecteur::vecteur(const vecteur &k){

n=k.n;
t=new int[n];
for(int i=0;i<n;i++){
t[i]=k.t[i];
 }
cout<<" appel de constructeur de recopie de vecteur: "<<n<<"\n";

}
vecteur::vecteur(int d){
if(d>0){
n=d;
}
t=new int[n];
for(int i=0;i<n;i++){
t[i]= i+1;
}
cout<<"appel de constructeur usuel de vecteur :"<<n<<"\n";

}
vecteur::~vecteur(){

cout<<"appel de destructeur de vecteur :"<<n<<"\n";

}
void produit (matrice m, vecteur v){
if(v.n!=m.l)
{
cout<<"produit impossible\n";
}
else{
vecteur vr(m.c);
for(int i=0;i<m.c;i++)
{
vr.t[i]=0;
for(int j=0;j<v.n;j++){
vr.t[i]+=v.t[j]*m.t[j][i];
}
}
for(int i=0;i<m.c;i++){
cout<<vr.t[i]<<"\n " ;
}
}
}

int main(){
matrice m4(3,0);
matrice m5=m4;
matrice m1(3,2);
vecteur v1(3);
 produit(m1,v1);
return 0;
}
Corrigé:
appel de constructeur usuel de matrice:4 4
appel de constructeur de recopie de matrice: 4 4
appel de constructeur usuel de matrice:3 2
appel de constructeur usuel de vecteur :3
appel de constructeur de recopie de vecteur: 3
appel de constructeur de recopie de matrice: 3 2
appel de constructeur usuel de vecteur :2
8
14
appel de destructeur de vecteur :2
appel de destructeur de matrice : 3 2
appel de destructeur de vecteur :3
appel de destructeur de vecteur :3
appel de destructeur de matrice : 3 2
appel de destructeur de matrice : 4 4
appel de destructeur de matrice : 4 4

Exercice:17

Soit la classe point défini comme suit :

// ************ classe point *********************
class point
{
int x, y ;
public :
point (int abs, int ord)
{
cout << "++ constr. point : " << abs << " " << ord << "\n" ;
x = abs ; y =ord ;
}
~point ()
{
cout << "-- destr. point : " << x << " " << y << "\n" ;
}
};

Soit la classe Poincol une classe dérivée de la classe point (dérivation publique)
La classe pointcol contient :
Deux variables (int col1 et int col2)
Un constructeur usuel permettant d’initialiser les variables x, y, col1 et col2 par les
valeurs de ses arguments.
Une fonction CalculeD() permettant de calculer la distance d’un point.

Ecrire un programme en C++ qui contient la classe point, la classe poincol avec la
définition de ses méthodes et la fonction main. Dans la fonction main crée un objet de la
classe poincol et calculer sa distance.
Note : Le statut de x et y est toujours privé.
L’ajout d’une autre fonction n’est pas accepté.
Corrigé:

#include <iostream>
#include<Cmath>
using namespace std;
class pointcol;

// ************ classe point *********************

class point
{
int x, y ;
public :
point (int abs, int ord)
{
cout << "++ constr. point : " << abs << " " << ord << "\n" ;
x = abs ; y =ord ;
}
~point ()
{
cout << "-- destr. point : " << x << " " << y << "\n" ;
}

friend class pointcol;

};

class pointcol:public point

{
int col1, col2;
public:
pointcol(int a, int b, int c, int d):point(a,b)
{
 col1=c;
col2=d;
}
void calcul3D()
{
double Ds=sqrt(x*x+y*y);
cout<<"Distance="<<Ds<<endl;
}
};

int main()
{
pointcol pc (2, 4, 1, 3);
pc.calcul3D();

}
Références