Université Hassan II-Mohammedia Année Universitaire : 2014-15

Faculté des sciences Ben M’sik

Département des Maths et Informatique

Serie n°:3_-Langage C++-

Exercice n°:1
Définir une classe chaine permettant de créer et de manipuler une chaîne de caractères:
données:
- longueur de la chaîne (entier)
- adresse d’une zone allouée dynamiquement
méthodes:
- constructeur chaine() initialise une chaîne vide
- constructeur chaine(char *) initialise avec la chaîne passée en argument
- constructeur par recopie chaine(chaine &)
- opérateurs affectation (=), comparaison (==), concaténation (+), accès à un caractère de
rang donné ([] )

Ecrire une fonction main() qui permet de tester ces fonctions et ces opérateurs sur des objets
de la classe chaine.
Exercice n°:2
1- Créer une classe "pile d’entiers naturels" de taille fixée à la création, et permettant
les
opérations usuelles sur une pile :
main()
{ int x;
Pile_entier s(100),p; // tableau de 100 entiers
[Link](10);
[Link]();
[Link](20);
[Link]();
[Link](30);
[Link]();
x=[Link]();
[Link]();
[Link]([Link]());
[Link]();
if([Link]()) x=[Link]();
[Link]();
[Link]();
[Link]();
cin>>x;
while([Link]()) [Link](x);
[Link]();
p=s;
[Link]();
while(![Link]()) [Link](x);
}

2- Reprendre le programme sur la pile d’entiers naturels, et essayer de trouver une notation
au moyen d’opérateurs et non plus de fonctions explicitement nommées "Empiler" ou
"Depiler".
Exercice n°:3
On souhaite manipuler des ensembles d’entiers sans doublon (chaque élément doit être
unique). Pour cela, on implémentera une instance de la classe Ensemble comme un tableau
dynamique d’entiers (le nombre effectif d’éléments du tableau sera toujours égal au cardinal
de l’ensemble), comme suit :

Class Ensemble
{
private :
in *tab ;
int taille;
int nbelts ;
public:
--------
};
Sachant qu’on désire pouvoir effectuer toutes les opérations figurant dans le main() suivant,
il vous est demandé :
1. De spécifier complètement la classe Ensemble
2. D’implémenter les constructeurs et destructeur.
3. D’implémenter les deux opérateurs >,l’un permettant d’indiquer si un ensemble
contient un élément particulier, l’autre permettant d’indiquer si un ensemble contient
un autre ensemble .
4. D’implémenter les deux opérateurs +, l’un permettant l’ajout physique d’un nouvel
élément, l’autre permettant de construire l’union de deux ensembles.
5. D’implémenter l’opérateur d’affectation

# include <iostream.h>
………..
………..
main()
{
Ensemble e1;// e est initialisé à vide
if ([Link]()) // test si e1 est vide
cout<< " e1 est vide ";
else
cout<< "e1 n’est pas vide" ;

cout << "cardinal de e1 est = " << [Link]()

Ensemble e2(e1) ; // les éléments de e2 sont identiques à ceux de e1

e2 + 17 ; // l’entier 17 est ajouté physiquement à e2, s’il n’est pas déjà présent dans e2
e2 + 11 ; // l’entier 11 est ajouté physiquement à e2, s’il n’est pas déjà présent dans e2
e2 + 3 ; // l’entier 3 est ajouté physiquement à e2, s’il n’est pas déjà présent dans e2
e1 + 7 ; // l’entier 7 est ajouté physiquement à e1, s’il n’est pas déjà présent dans e1

cout << e2; // les éléments de e2 sont affichés à l’écran

Ensemble e3,e4;
e3=e1+e2 ; // e3 est l’union de e1 et e2 (sans doublon)
if (e1 > 7) // si l’ensemble e1 contient l’élément 7
cout << "e1 contient 7 ";
else
cout << "e1 ne contient pas 7 ";

if (e2 > e1) // si l’ensemble e2 contient l’ensemble e1 (tout élément de e1 appartient à e2)
cout << "e2 contient e1 " ;
else
cout << "e2 ne contient pas e1 " ;

}
Exercice 1 :
#include <iostream>

#include <string.h>

using namespace std;

class chaine

int taille;

char *adr;

public:

chaine();

chaine(char *);

chaine(const chaine &);

chaine & operator=(const chaine &);

int operator==(const chaine &);

chaine operator+(const chaine &);

char & operator[](int);

friend ostream & operator<<(ostream &,const chaine &);

};

chaine::chaine()

taille=0;

adr= new char[taille];

chaine::chaine(char *v)

taille=strlen(v);
 adr= new char[taille];

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

adr[i]=v[i];

chaine::chaine(const chaine &v)

taille=[Link];

adr= new char[taille];

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

adr[i]=[Link][i];

chaine & chaine::operator=(const chaine &v)

if(this!=&v)

delete adr;

taille=[Link];

adr= new char[taille];

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

adr[i]=[Link][i];
 }

return (*this);

int chaine::operator==(const chaine &v)

int i=0;

while(i<taille && adr[i]==[Link][i])

i++;

if(i==taille)

return 1;

else

return 0;

chaine chaine::operator+(const chaine &v)

chaine res;

[Link]=taille+[Link];

[Link]=new char[[Link]];

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

[Link][i]=adr[i];

int j=0;

for(int i=taille; i<[Link]; i++)

 {

[Link][i]=[Link][j];

j++;

return res;

char & chaine::operator[](int i)

return adr[i];

ostream & operator<<(ostream &o,const chaine &v)

for(int i=0; i<[Link]; i++)

o<<[Link][i];

return o;

main()

char r[10]="NAOUFAL";

char s[10]="TOKANE";

chaine R(r);
 chaine S(s);

chaine U,V;

chaine T=S;

U=S;

cout<<"L'ELEMENT : "<<S[2]<<"\n";

if(T==S && U==S)

cout<<"TRUE\n";

else

cout<<"FALSE\n";
T=S+R;

cout<<T;

Exercice 2 :
#include <iostream>

using namespace std;

class Pile_entier

int *pile,taille,hauteur;

public:

Pile_entier(int);

Pile_entier(const Pile_entier &);

Pile_entier & operator=(const Pile_entier &);

 void Affiche();

int NonPleine();

void Empiler(int);

int NonVide();

int Depiler();

void Vide();

Pile_entier::Pile_entier(int N=20)

hauteur=0;

taille=N;

pile=new int[taille];

Pile_entier::Pile_entier(const Pile_entier &v)

hauteur=[Link];

taille=[Link];

pile=new int[taille];

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

pile[i]=[Link][i];

Pile_entier & Pile_entier::operator=(const Pile_entier &v)

{

if (this=&v)

delete pile;

hauteur=[Link];

taille=[Link];

pile=new int[taille];

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

pile[i]=[Link][i];

return(*this);

void Pile_entier::Affiche()

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

cout<<pile[i]<<" | ";

cout<<"\n";

int Pile_entier::NonPleine()

return(hauteur!=taille);

}
void Pile_entier::Empiler(int n)

if(!NonPleine)

cout<<"PILE PLEIN";

else

pile[hauteur++]=n;

int Pile_entier::NonVide()

return(hauteur!=0);

int Pile_entier::Depiler()

if(NonVide())

return(pile[--hauteur]);

else

{
cout<<"PILE VIDE";

return(pile[hauteur]);

void Pile_entier::Vide()

hauteur=0;

main()
{

int x;

Pile_entier s(100),p; // tableau de 100 entiers

[Link](10);

[Link]();

[Link](20);

[Link]();

[Link](30);

[Link]();

x=[Link]();

[Link]();

[Link]([Link]());

[Link]();

if([Link]())

x=[Link]();

[Link]();

[Link]();

[Link]();

while([Link]())

cin>>x;

[Link](x);

[Link]();

p=s;

[Link]();

while(![Link]()) [Link](x);

Exercice 3 :
#include <iostream>
using namespace std;

class Ensemble

int *tab;

int taille;

int nbelts;

public:
Ensemble(int);

Ensemble(const Ensemble &);

~Ensemble();

Ensemble & operator=(const Ensemble &);

friend ostream & operator<<(ostream &,const Ensemble &);

int estvide();

int cardinal();

int operator>(int);

int operator>(const Ensemble &);

void operator+(int);

Ensemble operator+(const Ensemble &);

};

Ensemble::Ensemble(int N=10)

taille=N;

tab=new int[taille];

nbelts=0;

Ensemble::Ensemble(const Ensemble &v)

taille=[Link];
 tab=new int[taille];

nbelts=[Link];

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

tab[i]=[Link][i];

Ensemble::~Ensemble()

delete tab;

Ensemble & Ensemble::operator=(const Ensemble &v)

if(this!=&v)

delete tab;

taille=[Link];

nbelts=[Link];

tab=new int[taille];

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

tab[i]=[Link][i];

return(*this);

}
ostream & operator<<(ostream &o,const Ensemble &v)

o<<"LES ELEMENTS SONT : ";

for (int i=0; i<[Link]; i++)

o<<[Link][i]<<", ";

return o;

int Ensemble::estvide()

return(nbelts==0);

int Ensemble::cardinal()

return(nbelts);

int Ensemble::operator>(int n)

int i=0;

while(i<nbelts && tab[i]!=n)

i++;

if(i==nbelts)

return 0;

else

return 1;

int Ensemble::operator>(const Ensemble &v)

{

int i=0;

while(i<nbelts && ((*this)>[Link][i]))

i++;

if(i==nbelts)

return 1;

else

return 0;

void Ensemble::operator+(int n)

if((*this)>n)

cout<<"ELEMENTS EXISTE DEJA\n";

else

if(nbelts==taille)

cout<<"ENSEMBLE PLEIN\n";

else

tab[nbelts++]=n;

Ensemble Ensemble::operator+(const Ensemble &v)

Ensemble U(taille+[Link]);

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

[Link][i]=tab[i];

[Link]=nbelts;
 for (int i=0; i<[Link]; i++)

U+[Link][i];

return U;

main()

Ensemble e1;// e est initialisé à vide

if ([Link]()) // test si e1 est vide

cout<< " e1 est vide ";

else

cout<< "e1 n’est pas vide" ;

cout << "cardinal de e1 est = " << [Link]();

Ensemble e2(e1) ; // les éléments de e2 sont identiques à ceux de e1

e2 + 17 ; // l’entier 17 est ajouté physiquement à e2, s’il n’est pas déjà présent dans e2

e2 + 11 ; // l’entier 11 est ajouté physiquement à e2, s’il n’est pas déjà présent dans e2

e2 + 3 ; // l’entier 3 est ajouté physiquement à e2, s’il n’est pas déjà présent dans e2

e1 + 7 ; // l’entier 7 est ajouté physiquement à e1, s’il n’est pas déjà présent dans e1

cout << e2; // les éléments de e2 sont affichés à l’écran

Ensemble e3,e4;

e3=e1+e2 ; // e3 est l’union de e1 et e2 (sans doublon)

if (e1 > 7) // si l’ensemble e1 contient l’élément 7

cout << "e1 contient 7 ";

else

cout << "e1 ne contient pas 7 ";

if (e2 > e1) // si l’ensemble e2 contient l’ensemble e1 (tout élément de e1 appartient à e2)

cout << "e2 contient e1 " ;

else
 cout << "e2 ne contient pas e1 " ;

}
Université Hassan II-Mohammedia Année Universitaire : 2014-15
Faculté des sciences Ben M’sik
Département des Maths et Informatique

Serie sur C++ et heritage

Exercice 1:
L'objet de cet exercice est d'utiliser une fonction amie qui est membre d'une autre classe
Soient les deux classes
Class matrice
{Float mat[3][3];
Public:
matrice (float t[3][3]);
vecteur prod(vecteur);
};
Class vecteur
{Float v[3];
Public:
vecteur (float t[3] );
friend vecteur matrice::prod(vecteur);
void affiche();
};
Ecrire une fonction main() qui permet de tester ces fonctions

Page n° :1/8
Exercice 2:
1°) On souhaite manipuler des tableaux de réels. Pour cela, on implémentera une instance de
la classe Tableau comme un tableau dynamique de réels, comme suit :
Class Tableau
{
private :
in *tab ;
int taille;
public:
--------
};

il vous est demandé :

 De spécifier complètement la classe Tableau
 D’implémenter la méthode Frequence qui calcule la fréquence d’une valeur VAL
entrée au clavier.
 D’implémenter la fonction amie remplace_18 qui remplace, dans le tableau tous les
nombres pairs par 18.
 D’implémenter la fonction amie affiche_8 qui affiche, à partir du tableau tous les
nombres qui se termine par 8.
 D’implémenter la méthode Supp_chiffre_3 qui supprime, à partir du tableau tous les
nombres qui ont trois chiffres.
 D’implémenter la méthode Tri qui permet de trier le tableau selon l’ordre croissant.
 D’implémenter la méthode Palindrome qui vérifie si un tableau est palindrome ou pas.
 D’implémenter l’opérateur +, permettant de réaliser la somme de deux tableaux de
même taille.
 D’implémenter l’opérateur *, permettant de réaliser le produit scalaire de deux
tableaux de même taille.
 D’implémenter l’opérateur *, permettant de réaliser le produit d’un tableau par un
scalaire.
 D’implémenter l’opérateur * comme méthode amie , permettant de réaliser le produit
d’un scalaire par un tableau.
 D’implémenter l’opérateur d’affectation
 Surdéfinir les opérateurs >> et << pour la saisie et l’affichage.

Page n° :2/8
Exercice n° :3
Soit une technique qui consiste à compter, en permanence, le nombre de références à un
emplacement (dynamique), c'est à dire le nombre de pointeurs le désignant à un moment
donné. Dans ces conditions, lorsqu'un objet est détruit, il suffit de n'en détruire la partie
dynamique que si son compteur de références est nul pour éviter les problèmes de risque de
libération multiple.
Pour mettre en œuvre cette technique, le compteur de références doit être mis à jour à chaque
fois que le nombre d'objets désignant l'emplacement correspondant risque d'être modifié.
Cela concerne donc:
 Le constructeur par recopie: il doit initialiser un nouvel objet pointant sur un emplacement
déjà référence et donc incrémenter son compteur de références,
 L'opérateur d'affectation; une instruction telle que a=b doit:
 Décrémenter le compteur de références de l'emplacement référencé par a et procéder à
sa libération lorsque le compteur est nul,
 Incrémenter le compteur de références de l'emplacement référencé par b.
Pour appliquer cette technique soit une classe vect dont la déclaration est la suivante:
# Include <iostream.h>
Struct element //structure de service pour la classe vect
{ int nref; //compteur de références
int *adr; // pointeur sur vecteur dynamique
};
Class vect
{ int nelem; //nombre de composantes du vecteur
element * adel; //pointeur sur partie dynamique
void decremente(); //fonction de service qui décrémente le compteur de
Public: //références et détruit si nécessaire
…
};
1°) Compléter la déclaration de la classe vect et donner sa définition, sachant qu'elle doit
disposer:
- d'un constructeur usuel,
- d'un constructeur par recopie,
- d'un destructeur,
- de la surdéfinition de l'opérateur d'affectation,
- de la surdéfinition de l'opérateur, qui permet l'accès à une des composantes du
vecteur,
- une fonction d'affichage du vecteur,
- des impressions permettant de suivre l'évolution des compteurs et des appels des
fonctions membres.

2°) Ecrire une fonction main() qui permet de tester ces fonctions et ces opérateurs sur des
objets de la classe vect.

Page n° :3/8
Exercice n° :4
1- Créer une classe "pile d’entiers naturels" de taille fixée à la création, et permettant
les
opérations usuelles sur une pile :
main()
{ int x;
Pile_entier s(100),p; // tableau de 100 entiers
[Link](10);
[Link]();
[Link](20);
[Link]();
[Link](30);
[Link]();
x=[Link]();
[Link]();
[Link]([Link]());
[Link]();
if([Link]()) x=[Link]();
[Link]();
[Link]();
[Link]();
cin>>x;
while([Link]()) [Link](x);
[Link]();
p=s;
[Link]();
while(![Link]()) [Link](x);
}
2- Reprendre le programme sur la pile d’entiers naturels, et essayer de trouver une notation
au moyen d’opérateurs et non plus de fonctions explicitement nommées "Empiler" ou
"Depiler".

3- Reprendre la question n :1, et donner une implantation utilisant le concept

d’héritage. Garder le même programme de test.

Page n° :4/8
Exercice n° :5
class Fraction
{
public:
Fraction();
Fraction(int i);
Fraction(int num,int den);
Fraction(Fraction &);
Fraction();
Void affiche();
Fraction operator+ (const Fraction & f);
Fraction operator- (const Fraction & f);
Fraction operator* (const Fraction & f);
Fraction operator/ (const Fraction & f);
private:
int num,den;
void normalise();
};
Voici le rôle de chaque fonction :
Fraction(); : le constructeur par défaut initialise la fraction à 0.
Fraction(int); : initialise la fraction à l'entier i.
Fraction(int num, int den); : initialise le numérateur et le dénominateur de la fraction.
Fraction operator+ (const Fraction & f); permet de faire la somme de 2 fractions.
Fraction operator- (const Fraction & f); permet de faire la différence de 2 fractions.
Fraction operator*(const Fraction & f); permet de faire la multiplications de 2 fractions.
Fraction operator/ (const Fraction & f); permet de faire la division de 2 fractions.
void normalise() : normalise la fraction. Le dénominateur doit être positif et la fraction
irréductible.
Ecrire un programme principal qui saisit au clavier 2 fractions f1 et f2 et qui affiche
E=(f1+3/4-f2)/(f1*f2-5/8)+4.
Définir une nouvelle classe FRACTIONSIMP dérivant de FRACTION, mais dans laquelle
les nombres rationnels sont simplifiés. On prévoira:
- Un constructeur recevant en arguments le numérateur et le dénominateur d'un rationnel;
- Un constructeur par recopie;
- Une fonction membre privée(nommée pgcd) qui retourne le pgcd de deux entiers.

Page n° :5/8
Exercice n° :6
1°) Définir une classe chaine permettant de créer et de manipuler une chaîne de caractères:
données:
- longueur de la chaîne (entier)
- adresse d’une zone allouée dynamiquement
méthodes:
- constructeur chaine() initialise une chaîne vide
- constructeur chaine(char *) initialise avec la chaîne passée en argument
- constructeur par recopie chaine(chaine &)
- opérateurs affectation (=), comparaison (==), concaténation (+), accès à un caractère de
rang donné ([] )

Ecrire une fonction main() qui permet de tester ces fonctions et ces opérateurs sur des objets
de la classe chaine.

2°) Définir une classe chaine_nombre qui hérite de la classe chaine en s'intéressant
uniquement à des chaînes numériques:
données:
- la valeur numérique de la chaine (entier)
méthodes:
- constructeur chaine_nombre(char *) initialise la chaîne avec appel du constructeur de la
classe chaine
- constructeur par recopie chaine_nombre(chaine &)
- fonction afficher (même nom que celui de la classe chaine)

Ecrire une fonction main() qui permet de tester ces fonctions sur des objets de la classe
chaine_nombre (essentiellement l'affichage d'un objet de la classe chaine_nombre comme un
objet de la classe chaine) .

Page n° :6/8
Exercice n° :7
On désire manipuler des polynômes à une variable. Pour cela, on implémentera une instance
de la classe polynôme comme un tableau dynamique de monômes. Les monômes sont rangés
par degrés croissants.
Chacun des monômes est déclaré de type :
Typedef Struct
{ float coef;
int deg;
} Monome;

class polynome
{ Monome * poly;
int taille;
int nbelts;
public:
.....
};
il vous est demandé :
1. De spécifier complètement la classe polynôme.
2. D’implémenter les constructeurs et destructeur.
3. D’implémenter l’opérateur >, permettant d’indiquer si un degré d’un monôme figure
dans la liste des degrés du polynôme.
4. D’implémenter les deux opérateurs +, l’un permettant l’ajout physique d’un nouveau
monôme, l’autre permettant de construire la somme de deux polynômes.
5. D’implémenter les deux opérateurs -, l’un permettant la réalisation de la différence
d’un polynôme et un monôme, l’autre permettant de construire la différence de deux
polynômes.
6. D’implémenter l’opérateur d’affectation.
7. Surdéfinir les opérateurs >> et << pour la saisie et l’affichage.
8. D’implémenter la fonction nettoyer permettant de supprimer du tableau tout les
monômes à coefficient nul.
9. D’implémenter la fonction evaluer permettant d’évaluer un polynôme à une variable.
10. D’implémenter la fonction deriver permettant de déterminer la dérivée d'un polynôme
11. Mettre en œuvre cette classe dans main().

Page n° :7/8
Exercice n° :8
On désire manipuler des polynômes à une variable . Pour représenter ceux-ci on propose une
structure de liste à simple chaînage:
Les monômes sont rangés par degrés croissants.
Chacun des monômes est déclaré de type :
Typedef Struct elt
{ float coef;
int deg;
Struct elt * suiv ;
} Monome;

Class polynome
{ Monome * poly;
public: .....
};
La classe polynôme doit contenir entre autre :
1) Ajout d’un monôme au polynôme poly
ADMON(nom de fonction par exemple): le coefficient c et le degré d sont donnés en entrée
ainsi que le polynôme poly (supposé déjà construit) ADMON ajoute le monôme (c,d) au
polynôme poly.
2) Affichage d’un polynôme Cnxn + Cn-1xn-1 +...+C1x + C0 .
Envisager un format d'affichage adéquat.
3) L’opérateur + qui réalise la somme des deux polynômes.
4) Evaluation d'un polynôme à une variable
5) Détermination de la dérivée d'un polynôme
Mettre en œuvre cette classe dans main().

Page n° :8/8
Exercice 1 :
#include <iostream>

using namespace std;

class vecteur;

class matrice

float mat[3][3];

public:

matrice(float t[3][3]);

friend vecteur & operator*(const vecteur &, const matrice &);

friend vecteur & operator*( const matrice &, const vecteur &);

friend ostream & operator<<(ostream &,const matrice &);

friend istream & operator>>(istream &, matrice &);

};

matrice::matrice(float t[3][3])

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

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

mat[i][j]=t[i][j];

ostream & operator<<(ostream &o,const matrice &A)

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

 {

o<<"|";

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

o<<[Link][i][j]<<" ";

o<<"|\n";

return o;

istream & operator>>(istream &i, matrice &A)

cout<<"LECTURE D'UNE MATRICE\n";

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

for(int k=0; k<3; k++)

cout<<"L'element ("<<j<<","<<k<<") : ";

i>>[Link][j][k];

return i;

class vecteur

float v[3];

public:

vecteur(float t[3]);

friend vecteur & operator*(const vecteur &,const matrice &);

 friend vecteur & operator*( const matrice &, const vecteur &);

friend ostream & operator<<(ostream &,const vecteur &);

friend istream & operator>>(istream &, vecteur &);

};

vecteur::vecteur(float t[3])

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

v[i]=t[i];

ostream & operator<<(ostream &o,const vecteur &A)

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

o<<"|"<<A.v[i]<<"|\n";

return o;

istream & operator>>(istream &i, vecteur &A)

cout<<"LECTURE D'UN VECTEUR\n";

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

cout<<"L'element ("<<j<<") : "; i>>A.v[j];

}
 return i;

vecteur & operator*(const vecteur &A, const matrice &B)

float a[3];

vecteur res(a);

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

float som=0;

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

{
som+=[Link][i][j]*A.v[j];

res.v[i]=som;

return res;

vecteur & operator*( const matrice &B, const vecteur &A)

return (A*B);

main()

float a[3];

vecteur A(a);

cin>>A;

cout<<A;
 float b[3][3];

matrice B(b);

cin>>B;

cout<<B;

float c[3];

vecteur C(c);

C=B*A;

C=A*B;

cout<<"LE PRODUIT DE MAT*VECT EST : \n"<<C;

Exercice 2 :
#include <iostream>

using namespace std;

class tab

float *t;

int taille;

public:

tab(int);

tab(const tab &);

~tab();
tab & operator=(const tab &);

friend ostream & operator<<(ostream &, const tab &);

friend istream & operator>>(istream &, tab &);

int frequence(float);
 friend void remplace_18(tab &);

friend void affiche_8(tab &);

void supp_chiffre_3();

void tri();

int palyndrome();

tab & operator+(const tab &);

float & operator*(const tab &);

tab & operator*(float);

friend tab & operator*(float, const tab &);

};

tab::tab(int N=10)

taille=N;

t=new float[taille];

tab::tab(const tab &v)

taille=[Link];

delete t;

t=new float[taille];

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

t[i]=v.t[i];

tab::~tab()

delete t;
}

tab & tab::operator=(const tab &v)

if(this!=&v)

taille=[Link];

delete t;

t=new float[taille];

for(int i; i<taille; i++)

t[i]=v.t[i];

return(*this);

ostream & operator<<(ostream &o, const tab &v)

o<<"Les elements sont : ";

for(int i=0; i<[Link]; i++)

o<<v.t[i]<<" ";

return o;

istream & operator>>(istream &i, tab &v)

for (int j=0; j < [Link]; j++)

 {

cout<<"L'element "<<j<<" :\n";

i>>v.t[j];

return i;

int tab::frequence(float x)

int k=0;

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

if(t[i]==x)

k++;

return k;

void remplace_18(tab &v)

int k=0;

for(int i=0; i<[Link]; i++)

if(v.t[i]/2==0)

v.t[i]=18;

void affiche_8(tab &v)

cout<<"Les nombres qui se terminent par 8 :\n";

for (int i = 0; i < [Link]; i++)

{
 int Nb;

Nb=v.t[i];

while(Nb<1 || Nb>9)

Nb/=10;

if (Nb==8)

cout<<v.t[i]<<" ";

void tab::supp_chiffre_3()

int k=0;

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

int Nb,j;

j=0;

Nb=t[i];
while(Nb!=0)

Nb/=10;

j++;

if(j==3)

t[i]=t[k];

k++;

taille=k;
}

void tab::tri()

int prm=1;

float tmp;

do

{
prm=0;

for (int i=0; i<taille-1; i++)

if (t[i]>t[i+1])

tmp=t[i];

t[i]=t[i+1];

t[i+1]=tmp;

prm=1;

}while(prm==1);

int tab::palyndrome()

int i=0;

while(i<taille && t[i]==t[taille-i-1])

i++;

if(i==taille)

return 1;

else
 return 0;

tab & tab::operator+(const tab &v)

tab res(taille);

if(taille==[Link])

for (int i=0; i<[Link]; i++)

res.t[i]=t[i]+v.t[i];

return res;

float & tab::operator*(const tab &v)

if(taille==[Link])

float som=0;

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

som+=t[i]*v.t[i];

return som;

else

cout<<"taille different impossible d'effectuer le produit!";

}
tab & tab::operator*(float x)

tab res(taille);

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

res.t[i]=t[i]*x;

return res;

tab & operator*(float x,const tab &v)

tab res([Link]);

for (int i = 0; i < [Link]; i++)

res.t[i]=v.t[i]*x;

return res;

int main()

/*tab A(3);

cin>>A;

//cout<<A;
float x=2;

tab C(3);

cin>>C;

x=C*A;
 cout<<x;

*/

tab D(3);

cin>>D;

D=2*D;

cout<<D;

Exercice 3 :
#include <iostream>

using namespace std;

typedef struct element //structure de service pour la classe vect

int nref; //compteur de références

int *adr; // pointeur sur vecteur dynamique

} element;

class vect

int nbelts;

element * adel;

int decremente();

public:

vect(int);

vect(const vect &);

 ~vect();

vect & operator=(const vect &);

int operator[](int);

friend ostream & operator<<(ostream &, const vect &);

friend istream & operator>>(istream &, vect &);

};

int vect::decremente()

(adel->nref)--; if(adel-

>nref==0)

{
delete adel->adr;

delete adel;

vect::vect(int N=12)

nbelts=N;

adel=new element;

adel->adr=new int[nbelts]; adel-

>nref=1;

vect::vect(const vect &v)

nbelts=[Link];

adel=[Link];

(adel->nref)++;
}

vect::~vect()

decremente();

vect & vect::operator=(const vect &v)

if(this!=&v)

decremente();

nbelts=[Link];

adel=[Link]; (adel-

>nref)++;

return(*this);

int vect::operator[](int i)

return adel->adr[i];

ostream & operator<<(ostream &o, const vect &v)

o<<"Les elements sont : ";

for(int i=0; i<[Link]; i++)

o<<[Link]->adr[i]<<" ";

}
 return o;

istream & operator>>(istream &i, vect &v)

for(int j=0; j<[Link]; j++)

cout<<"Donner l'element "<<j<<" : "; i>>[Link]-

>adr[j];

}
return i;

int main()

vect A(4);

cin>>A;

vect B=A;

vect C;

C=A;

cout<<A<<"\n";

cout<<B<<"\n";

cout<<C<<"\n";

cout<<B[2];

Exercice 4 :

Exercice 5 :
#include <iostream>
class Fraction

protected:

int num,den;

void normalise();

public:
Fraction();

Fraction(int);

Fraction(int, int);

Fraction(const Fraction &);

~Fraction();

friend ostream & operator<<(ostream &, const Fraction &);

Fraction & operator+(const Fraction &);

Fraction & operator-(const Fraction &);

Fraction & operator*(const Fraction &);

Fraction & operator/(const Fraction &);

};

Fraction::Fraction()

num=0;

den=1;

Fraction::Fraction(int N)

num=N;

den=1;

}
Fraction::Fraction(int N, int D)

num=N;

den=D;

Fraction::Fraction(const Fraction &v)

num=[Link];

den=[Link];

Fraction::~Fraction()

cout<<"DESTRUCTION";

ostream & operator<<(ostream &o, const Fraction &v)

o<<[Link]<<"/"<<[Link]<<"\n";

return o;

Fraction & Fraction::operator+(const Fraction &v)

Fraction res;

[Link]=num*[Link]+[Link]*den;

[Link]=den*[Link];

return res;

}
Fraction & Fraction::operator-(const Fraction &v)

Fraction w; [Link]=-

[Link]; [Link]=[Link];

return ((*this)+w);

Fraction & Fraction::operator*(const Fraction &v)

Fraction res;

[Link]=num*[Link];

[Link]=den*[Link];

return res;

Fraction & Fraction::operator/(const Fraction &)

Fraction w;

[Link]=[Link];

[Link]=[Link];

return ((*this)*w);

void Fraction::normalise()

if(den<0)
 {

num=-num; den=-

den;

class FRACTIONSIMP:public Fraction

int pgcd(int,int);

public:

FRACTIONSIMP(int,int);

FRACTIONSIMP(const FRACTIONSIMP &);

~FRACTIONSIMP();

};

FRACTIONSIMP::FRACTIONSIMP(int N, int D):Fraction(N,D)

int a=pgcd(num,den);

num=num/a;

den=den/a;

}
FRACTIONSIMP::FRACTIONSIMP(const FRACTIONSIMP &v):Fraction(V)

int a=pgcd(num,den);

num=num/a;

den=den/a;

int FRACTIONSIMP::pgcd(int a, int b)

if(b==0)
 return a;

return(pgcd(b,a%b));

Exercice 6 :
#include <iostream>

#include <string.h>

#include <math.h>

using namespace std;

class chaine

protected:

int taille;

char *s;

public:

chaine();

chaine(char *);

chaine(const chaine &);

~chaine();

chaine & operator=(const chaine &);

friend ostream & operator<<(ostream &, const chaine &);

int operator==(const chaine &);

chaine & operator+(const chaine &);

char & operator[](int);

};

chaine::chaine()

taille=1;
 s=new char[taille];

chaine::chaine(char *c)

taille=strlen(c);

s=new char[taille];

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

s[i]=c[i];

chaine::chaine(const chaine &v)

taille=[Link];

s=new char[taille];

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

s[i]=v.s[i];

chaine::~chaine()

delete s;

chaine & chaine::operator=(const chaine &v)

if(this!=&v)
 {

delete s;

taille=[Link];

s=new char[taille];

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

{

s[i]=v.s[i];

return (*this);

ostream & operator<<(ostream &o, const chaine &v)

for (int i=0; i<[Link]; i++)

o<<v.s[i];

o<<"\n";

return o;

int chaine::operator==(const chaine &v)

int i=0;

if(taille==[Link])

while(i<taille && s[i]==v.s[i])

i++;

if(i==taille)

return 1;
 else

return 0;

else

return 0;

chaine & chaine::operator+(const chaine &v)

chaine res;

[Link]=(taille+[Link]);

cout<<"";

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

res.s[i]=s[i];

int j=taille;

for (int i=0; i<[Link]; i++)

res.s[j]=v.s[i];

j++;

return res;

char & chaine::operator[](int i)

return s[i];

class chaine_nbr: public chaine

{

int nbr;

public:

chaine_nbr(char *);

chaine_nbr(const chaine &);

friend ostream & operator<<(ostream &, const chaine &);

};

chaine_nbr::chaine_nbr(char *c):chaine(c)

int i=0;

while(i<taille && isdigit(s[i]))

nbr+=pow(taille-i,s[i]);

i++;

chaine_nbr::chaine_nbr(const chaine &v):chaine(v)

int i=0;

while(i<taille && isdigit(s[i]))

nbr+=pow(taille-i,10)*s[i];

i++;

}
}

int main()

chaine N1;
 chaine N("NAOUFAL");

chaine B("BADR");

chaine B1=B;

N1=N;

cout<<"N : "<<N;

cout<<"N1 : "<<N1;

cout<<"B : "<<B;

cout<<"B1 : "<<B1;

int cmp;

cmp=(N==B);

cout<<"N==B : "<<cmp;

cmp=(N==N1);

cout<<"\nN==N1 : "<<cmp;

chaine F;

F=N+B1;

cout<<"\nB+N : "<<F;

cout<<"RE"<<N[1]<<N[6]<<" M"<<N[5]<<B[2]<<B[3]<<"I"<<B[2]<<" C.F\n";

chaine_nbr C("45j");

cout<<C;

Exercice 7 :
#include <iostream>

#include <math.h>

using namespace std;

typedef struct

float coef;

int deg;
}Mono;

class Poly

Mono *p;

int taille;

int nbelts;

void nettoyer(int);
public:

Poly(int);

Poly(const Poly &);

~Poly();
Poly & operator=(const Poly &);

friend ostream & operator<<(ostream &,const Poly &);

int operator>(int);

void operator+(const Mono &);

Poly operator+(const Poly &);

void operator-(const Mono &);

Poly operator-(const Poly &);

friend istream & operator>>(istream &, Poly &);

float evaluer(float);

void deriver();

};

Poly::Poly(int N=10)

taille=N;

p=new Mono[taille];

nbelts=0;

}
Poly::Poly(const Poly &v)

taille=[Link];

p= new Mono[taille];

nbelts=[Link];

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

p[i]=v.p[i];

Poly::~Poly()

delete p;

Poly & Poly::operator=(const Poly &v)

if (this!=&v)

delete p;

taille=[Link];

p=new Mono[taille];

nbelts=[Link];

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

p[i]=v.p[i];

return (*this);

}
ostream & operator<<(ostream &o,const Poly &v)

if (v.p[0].deg==0)

o<<v.p[0].coef<<"\n";

else

o<<v.p[0].coef<<"X^"<<v.p[0].deg;

for (int i=0; i <[Link]-1; i++)

{
if(v.p[i].coef>0)

o<<" +"<<v.p[i].coef<<"X^"<<v.p[i].deg;

else

o<<" -"<<-v.p[i].coef<<"X^"<<v.p[i].deg;

int m=[Link]-1;

if (v.p[m].deg=0)

if(v.p[m].coef>0)

o<<" +"<<v.p[m].coef<<"\n"<<v.p[m].deg;

else

o<<" -"<<-v.p[m].coef<<"\n"<<v.p[m].deg;
 }

else

if(v.p[m].coef>0)

o<<" +"<<v.p[m].coef<<"X^"<<v.p[m].deg<<"\n";

else

o<<" -"<<-v.p[m].coef<<"X^"<<v.p[m].deg<<"\n";

int Poly::operator>(int d)

int i=0;

while(i<nbelts && p[i].deg!=d)

i++;

if(i==nbelts)

return -1;

else

return i;

void Poly::nettoyer(int indice)

{

for (int i=indice; i<nbelts-1; i++)

p[i]=p[i+1];

nbelts--;

void Poly::operator+(const Mono &v)

int a=(*this)>[Link];

if(a!=-1)

p[a].coef+=[Link];

if(p[a].coef==0)

nettoyer(a);

else

if(taille!=nbelts)

int i=nbelts-1;

while(i>-1 && T[i].deg<[Link])

t[i+1]=t[i];

i--;

p[i]=v;

}
 else

cout<<"TABLEAU PLEIN \n";

Poly & Poly::operator+(const Poly &v)

Poly res(taille+[Link]);

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

{
res.p[i]=p[i];

for (int i=0; i <[Link]; i++)

res+v.p[i];

return res;

void Poly::operator-(const Mono &v)

Mono w=v;

[Link]=-[Link];

(*this)+w;

Poly & Poly::operator-(const Poly &v)

{
 Poly w=v;

for (int i=0; i <[Link]; i++)

w.p[i].coef=-v.p[i].coef;

return (*this)+w;

istream & operator>>(istream &i, Poly &v)

cout<<"Donnez le nombre de monome : ";

int n;

i>>n;

[Link]=n;

for (int j=0; j < [Link]; j++)

cout<<"\nDonnez le degre du monome numero"<<j<<" : ";

i>>v.p[j].deg;

cout<<"\nDonnez le coeficient du monome numero"<<j<<" : ";

i>>v.p[j].coef;

return i;

float Poly::evaluer(float x)

float a,s=0;

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

{
 a=p[i].coef*pow(x,p[i].deg);

s+=a;

return s;

void Poly::deriver()

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

p[i].coef=(p[i].coef)*(p[i].deg);

p[i].deg=(p[i].deg)-1;

int main()

Poly A(10);

cin>>A;

cout<<A;

Poly B=A;