Constructeurs et destructeurs en C++ - Applications résolues

1) Definir une classe (type abstrait de dates) pour memoriser et travailler avec des nombres complexes, qui doivent avoir:
- dates membre: elements necessaires pour la memorisation de la partie reelle et de celle imaginaire d’un nombre complexe;
- fonctions membre pour memoriser les dates dans un nombre complexe, calcule du module, affichage d’un nombre complexe et somme, et le produit entre deux nombres complexes.
On demande l’existence d’un constructeur explicite d’initialisation et l’un de copier (transferer les dates).

#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
 
class complex
{
	float a,b; //a – partie reelle, b – partie imaginaire
	public:
	void atribution(float=0,float=0);
	void lire();
	float& retre();
	float& retim();
	complex(float,float);
	complex(){}
	complex(complex&);
	void affichage(char*);
	float modul();
 
	//Somme de deux nombres complexes par plusieurs versions
	//1. avec transmision par le type rezulté
	complex somme1(complex); /*un nombre complexe est celui transmis par l’objet curent, 
				le deuxieme nombre complexe est celui transmis par parametre*/
 
	//2. avec transmision par la ligne des parametres - transfer par l’adresse
	void somme2(complex,complex*);
 
	/*3. avec transmision par la ligne des parametres- transfer par reference*/
	void somme3(complex,complex&);
 
	//produit de deux nombres complexes
	complex produit(complex);
};
 
void complex::atribution(float x, float y)
{
	a=x; b=y;
}
 
void complex::lire()
{
	cout<<"\partie reelle: ";
	cin>>a;
	cout<<"\partie imaginaire: ";
	cin>>b;
}
 
	float& complex::retre()
	{
		return a;
	}
	float& complex::retim()
	{
		return b;
	}
 
	complex::complex(float x, float y)
	{
		a=x; b=y;
	}
 
	complex::complex(complex& z)
	{
		a=z.a;
		b=z.b;
	}
 
void complex::affichage(char* s)
{
	cout<<"Nombre complexe "<<s<<" este: "<<a;
	cout.setf(ios::showpos);
	cout<<b<<"*i\n";
	cout.unsetf(ios::showpos);
}
 
float complex::modul()
{
	return sqrt(pow(a,2)+pow(b,2));
}
	/*Realiser la somme entre le nombre complexe reprezenté par l’objet
	curent, qui va appeller la fonction, et le nombre complexe transmis 
	par l’objet au nom "z" de la ligne de parametres*/
 
complex complex::somme1(complex z)
{
	complex r;
	r.a=a+z.a;
	r.b=b+z.b;
	return r;
}
 
void complex::somme2(complex z,complex* r)
{
	r->a=a+z.a;
	r->b=b+z.b;
}
 
void complex::somme3(complex z,complex& r)
{
	r.a=a+z.a;
	r.b=b+z.b;
}
 
complex complex::produit(complex z)
{
	complex r;
	r.a=a*z.a-b*z.b;
	r.b=a*z.b+b*z.a;
	return r;
}
 
void main()
{
	/*1.Introduire des dates dans un nombre complexe avec la fonction d’atribution*/
	complex z1; /*appel du constructeur d’initialisation sans parametres et
	sans corp defini*/
 
	int a,b; /*ne faites pas de confusion: a et b d’ici ne sont pas celles de la classe, 
		car les autres sont protegés et on ne peut pas avoir acces d’en dehors de la classe*/
 
	cout<<"Atribuer des valeurs lus aux parties reelles et imaginaires.\n";
	cout<<"\tpartie reelle: ";
	cin>>a;
	cout<<"\tpartie imaginaire: ";
	cin>>b;
	z1.atribution(a,b);
 
	//2.introduire les dates dans un nombre complexe par le lire
	complex z2;
	cout<<"Lire un nombre complexe.\n";
	z2.lire();
 
	//3.introduire directe la valeur de la partie reelle et imaginaire
	complex z3;
	cout<<"introduire directe partie reelle et imaginaire, dates.\n";
	cout<<"\tpartie reelle: ";
	cin>>z3.retre();
	int c;
	cout<<"\tpartie imaginaire: ";
	cin>>c;
	z3.retim()=c; /*ce transfert est possible car la fonction retourne une reference*/
 
	/*4.introduire des dates dans un nombre complexe par l’intermede du constructeur 
	d’initialisation avec les parametres.*/
	cout<<"on a introduit des dates par un constructeur d’initialisation.\n";
	complex z4(3,-2); /*on peut donner ou lire les valeurs*/
 
	//affichage nombres complexes
	z1.affichage("z1");
	z2.affichage("z2");
	z3.affichage("z3");
	z4.affichage("z4");
 
	//Somme de deux nombres complexes
	complex s; //on peut appeller les trois fonctions de calcule de la somme
	z1.somme3(z2,s); //s=z1+z2
	s.affichage("z1+z2");
 
	//produit de deux nombres complexes
	complex p;
	p=z1.produit(z2); //p=z1*z2
	p.affichage("z1*z2");
 
	int g;
	cin >>g;
}

2) Implementer les operations sur une stive statique. Pour acela on va declarer une classe SStive et des methodes pour chaque operation: definir la classe, implementer des methodes definies, utiliser la classe SStiva.

#include <iostream>
#include <fstream>
#include <math.h>
#define dim 20
using namespace std;
class Sstiva
{
	int s[dim];
	int haut; //le vif de stive
	public:
	Sstiva();
	~Sstiva();
	void Push(int e); //introduire l’element e dans la stive
	int Pop(); //extraire un element de la strive. Appliquer la technique LIFO
	int Longueur() //retourne la longueur de la stive
	{
		return haut;
	}
	int Elem(int index); //retour de l’element sur l’indexe
	void Affichage();
};
Sstiva::Sstiva(void)
{
	haut=0;
	cout<<"Stive initialiséeendl";
}
Sstiva::~Sstiva(void)
{
	if(haut==0)
	cout<<"Stive detruite."<<endl;
}
void Sstiva::Push(int e)
{
	if(haut==dim)
	{
		cout<<"Stive est pleine."<<endl;
		return; //sortie fortuite de la fonction
	}
	s[haut]=e;
	haut++;
}
int Sstiva::Pop(void)
{
	if(haut==0)
	{
		cout<<"Stive depassée"<<endl;
		return 0;
	}
	haut--;
	return s[haut];
}
int Sstiva::Elem(int index)
{
	return s[index-1];
}
void Sstiva::Affichage()
{
	if(haut)
	{
		for(int i=0;i<haut;i++)
		cout<<s[i]<<" ";
		cout<<endl;
		return;
	}
}
void main()
{
	Sstiva ob;
	int e; //variable qui retient les variables imntrodites dans la stive
	do
	{
		cout<<"Donnez l’element (-1=enlever, 0=stop): ";
		cin>>e;
		if(e)
		if(e!=(-1))
		{
			ob.Push(e);
			ob.Affichage();
			cout<<"Dimension de la stive est: "<<ob.Longueur()<<endl;
		}
		else
		{
			ob.Pop();
			ob.~Sstiva();
			ob.Affichage();
		}
	} while(e);
 
	int g;
	cin >>g;
}