IFT1166 --- Hiver 2K --- Demo04 --- 02 Février 2K

 

IFT1166 -- Démonstration # 4

 

Contenu

- reprise de l'exercice 4 de la démonstration -3-

- des questions sur le TP01?

- quelques astuces de programmation.

- les membres statiques

- les fonctions membres

- l'autoréférence THIS

- constructeurs, destructeurs, constructeurs de recopie

 

 

Exercice 1

Ce programme est-il syntaxiquement correct (cad peut-il être compilé) ? Dans la négative, corrigez-le.

------------------------------------------------------

#include <iostream.h>

class partage {

int a;

static int b=100;

public :

static int c=200;

static void init(int i, int j,int k)

{

a=i;

b=j;

c=k;

}

void afficher();

};

 

void partage:afficher()

{

cout << "la variable statique a : " << a << endl;

cout << "la variable b : " << b << endl;

cout << "la variable statique c : " << c << endl;

}

int main(void)

{

partage x,y;

x.init(1,1);

x.afficher();

y.init(2,2);

y.afficher();

x.afficher();

partage::c++;

partage::a++;

cout << "la variable statique c vaut: " << partage::c << endl;

cout << "la variable statique a vaut: " << partage::a << endl;

return 0;

}

------------------------------------------------------

 

Exercice 2

Écrire le programme suivant:

Soit la classe livres ayant :

Deux membres privés : auteur (du livre) et nom (du livre);

Un constructeur pour initialiser les membres privés, à titre d'exemple par:

Auteur : Albert Camus & Arthur Koestler

Nom: reflexions sur la peine capitale

Un destructeur;

Deux fonctions membres publiques, la première permet d'afficher en sortie les membres privés, la seconde affiche ces même membre mais cette fois en utilisant le pointeur autoréférence THIS.

 

 

Exercice 3

Écrivez une classe nommée pile_entier permettant de gérer une pile d'entiers. Ces derniers seront conservés dans un tableau d'entiers alloués dynamiquement. La classe comportera les fonctions membres suivantes:

pile_entier (int n)

Constructeur allouant dynamiquement un emplacement de n entiers,

pile_entier ()

Constructeur sans argument allouent par défaut un emplacement de vingt entiers,

~pile_entier ()

Destructeur,

void empile (int p)

Ajouter l'entier p sur la pile,

int depile ()

Fournit la valeur de l'entier situé en haut de la pile, en le supprimant de la pile,

int pleine ()

Fournit 1, si la pile est pleine, 0 sinon,

int vide ()

Fournit 1 si la pile est vide, 0 sinon,

 

Écrivez une fonction main, utilisant des objets automatiques et dynamiques du type pile_entier défini précédemment.

Mettez en évidence les problèmes posés par des déclarations de la forme:

pile_entier a(10);

pile_entier b = a;

Ajouter à la classe pile_entier le constructeur de recopie permettant de régler les problèmes précédents.

 

 

Exercice 4

Quel sera le résultat du programme suivant.

 

------------------------------------------------------------

#include <iostream.h>

class compte

{

float solde;

int nip;

static int nb;

public:

~compte () {

cout << "D "<< nb << endl;

nb--;

}

compte (float m, int n) {

nb++; solde = m; nip =n;

cout << "C "<< nb << endl;

}

compte (const compte& autre){

nb++; solde = autre.solde; nip = autre.nip;

cout << "R " << nb << endl;

}

};

int compte::nb = 0;

void p_val(compte c) { cout << "p_val" << endl;}

void p_ref(compte& c) { cout << "p_ref" << endl;}

int main()

{

compte c1(100, 111);

compte c2(200, 222);

compte c3 = c2;

compte c4(c1);

c3 = c2;

p_ref(c1);

p_val(c1);

compte* pc = new compte(800, 333);

delete pc;

compte* pc2 = new compte(c1);

delete pc2;

compte banque[3] = {c1, c2, c3};

return 0;

}

------------------------------------------------------------