Classes et objets en C++ - Applications résolues

1) Decrire une classe „complexe” qui permettra la memorisation de la partie reelle et de celle imaginaire dans un nombre complexe et calcule son module. Les dates n’auront aucune protection dans la classe, pour avoir acces directe d’en dehors.
Realiser un programme qui utilise cette classe et lit d’un nombre complexe, en l’affichant avec son module.

#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
 
class complex
{
	public:
	float a,b;
	float modul()
	{
		return sqrt(pow(a,2)+pow(b,2));
	}
};
void main()
{
	complex z;
	cout<<"Introduire le nombrecomplexe: \n";
	cout<<"\tPartie reelle: ";
	cin>>z.a;
	cout<<"\tPartie imaginaire: ";
	cin>>z.b;
 
	cout<<"\nNombre complexe est: ("<<z.a<<","<<z.b<<")";
	cout<<"\nLe module est: "<<z.modul()<<endl;
 
	int g;
	cin >>g;
}

2) Decrire une classe „complexe” qui mermet la memorisation de la partie reelle et imaginaire dans un nombre complexe et calkcule son module. Les dates n’auront aucune protection dans la classe, pour avoir acces directe d’en dehors. Realiser un programme qui une chaine de nombres complexe, et affiche les nombres qui ont le maximum et le minimum d’entre les modules avec leurs modules.

#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
class complex
{
	public:
	float a,b;
	float modul()
	{
		return sqrt(pow(a,2)+pow(b,2));
	}
};
void main()
{
	complex v[20]; //chaine de maximum 20 elements des nombres complexes
	float max,min; //modules minimum et maximum
	int n; //dimension reelle de la chaine
	int m,M; //l’indice des elements minimum et maximum

	cout<<"Introduire n: "; cin>>n;
	for(int i=0;i<n;i++)
	{
		cout<<"Nombre complexe "<<i+1<<" este: "<<endl;
		cout<<"\tpartie reelle: "; cin>>v[i].a;
		cout<<"\tpartie imaginaire: "; cin>>v[i].b;
	}
 
	max=v[0].modul();
	min=v[0].modul();
	m=0;
	M=0;
 
	for(int i=1;i<n;i++)
	if (v[i].modul()<min)
	{
		min=v[i].modul();
		m=i;
	}
	else if (v[i].modul()>max)
	{
		max=v[i].modul();
		M=i;
	}
 
	cout<<"\nNombre complexe avec le  module maximum: ("<<v[M].a<<","<<v[M].b<<") - modul: "<<max;
	cout<<"\nNombre complexe avec le module minimum: ("<<v[m].a<<","<<v[m].b<<") - modul: "<<min;
 
	int g;
	cin >>g;
}

3) Realiser une application avec un type abstrait de dates (une classe) qui petmet la memorisation des dates dans un nombre complexe, quand on protege la partie reelle et imaginaire pour la visibilite en dehors de la classe. La classe contiendra des elements de base, la memorisation des dates dans un nombre complexe et son afficher.

#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
class complex
{
	private: // implicite
	float a,b; //a – partie reelle, b – partie imaginaire
	public:
void lire(char* s) //fonction d’introduire les dates dans un nombre complexe
/*cette fonction se developpera dans l’interieur d la classe, comme fonction in-line*/
	{
cout<<"Introduire les dates du nombre complexe "<<s<<endl; /*au lieu de de endl on pouvait dire '\n' or "\n"*/
		cout<<"\tpartie reelle: ";
		cin>>a;
		cout<<"\tpartie imaginaire: ";
		cin>>b;
	}
	void afficher(char*); //fonction pour l’afficher des dates dans un nombre complexe
/*fonctiona <afficher> sera developpee dans la classe, comme fonction off-line*/
};
void complex::afficher(char* s)
{
	cout<<"Nombre complexe "<<s<<" est: "<<a;
	cout.setf(ios::showpos); //ajouter un signe '+' aux valeurs positives
	cout<<b<<"*i"<<endl;
	cout.unsetf(ios::showpos); //on va annuler le signe '+' pour les valeurs positives
}
void main()
{
	//on declare un objet de la classe anterieure
	complex z1;
/*appellons la fonction de lire pour cet objet (il devient objet courrent)*/
	z1.lire("z1");
	z1.afficher("z1");
	cout<<endl;
/*on a fait une declaration d’objet statique. 
Mais si l’objet est l’un dinamique?*/
	complex* z2;
	z2=new complex; //on utilise l’opperateur d’allocation de memoire de C++, <new>
	z2->lire("z2");
	z2->afficher("z2");
 
	int g;
	cin >>g;
}

4) Realiser une application avec un type abstrait de dates (une classe) qui petmet la memorisation des dates dans un nombre complexe, quand on protege la partie reelle et imaginaire pour la visibilite en dehors de la classe. La classe contiendra des elements de base, la memorisation des dates dans un nombre complexe et son afficher.
Realiser aussi les operations de somme ou produit entre deux nombres complexes.

 
#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
class complex
{
	private: //etait implicite
	float a,b; //a – partie reelle, b – partie imaginaire
	public:
void lire(char* s) //fonction d’introduire les dates dans un nombre complexe
/*fonction dans l’interieur de la classe, comme fonction in-line*/
	{
cout<<"Introduire les dates pour le nombre complexe "<<s<<endl; /*au lieu de endl ca va aussi '\n' sau "\n"*/
		cout<<"\tpartie reelle: ";
		cin>>a;
		cout<<"\tpartie imaginaire: ";
		cin>>b;
	}
 
	void afficher(char*); //fonction d’afficher des dates dans un nombre complexe 
/*fonction dans l’interieur de la classe comme off-line*/
 
	//Plusieurs variantes de calcule de la somme de deux nombres complexes
 
	//1. somme, version resultat
	complex somme1(complex); /*la fonction retourne un nombre complexe comme resultat de l’expression somme, 
	et comme participants sont des expressions type nombre complexe:
	l’un est l’objet courrent qui appellera la fonction, le deuxieme c’est 
	le parametre inclu dans la liste des parametres de la fonction*/
 
	//2. la somme dans la version resultat transmise par la ligne des parametres – par le type de reference
	void somme2(complex, complex&); /*opperateur binnaire, donc il faut deux opperateurs:
	premier opperand qui particippe a la relation est l’objet courrent,
	et le deuxieme est le premier parametre de la fonction. Le resultat 
	obtenu est transmis par le deuxieme perimetre de la fonction, l’expression de type reference */
 
	//3. la somme dans la version resultat transmis par la ligne des parametres – par l’adresse
	void somme3(complex, complex*);
	//Produit de deux nombres complexes
	complex produs(complex);
};
 
void complex::afficher(char* s)
{
	cout<<"Nr. complex "<<s<<" este: "<<a;
	cout.setf(ios::showpos); //on ajoute un signe '+' aux valeurs positives
	cout<<b<<"*i"<<endl;
	cout.unsetf(ios::showpos); //annuler l’opperation d’afficher implicite avec le signe
}
 
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;
}
 
void main()
{
	//on declare un objet pour la classe anterieure
	complex z1;
 
	/*on appelle la fonction de lire pour cet objet (il devient objet courrent)*/
	z1.lire("z1");
	z1.afficher("z1");
	cout<<endl;
	/*on a fait une declaration d’objet statique. 
	Si l’objet est dinamique?*/
 
	complex* z2;
	z2=new complex; //on utilise opperateur d’allocation de memoire de C++, <new>
	z2->lire("z2");
	z2->afficher("z2");
	cout<<endl; //on passe sur une nouvelle ligne, laissant une libre

	complex z3;
	z3=z1.somme1(*z2); /*calculer la somme entre les nombres complexes z1 et z2, 
						somme qui sera inscrite en z3*/
	z3.afficher("z1+z2");
	complex z4;
	z1.somme2(*z2,z4); 	//z4=z1+z2
	z4.afficher("z1+z2");
	complex z5;
	z1.somme3(*z2,&z5); 	//z5=z1+z2
	z5.afficher("z1+z2");
 
	int g;
	cin >>g;
}