C++: Constructori si Destructori - aplicatii rezolvate


1) Sa se defineasca o clasa (un tip abstract de date) pentru memorarea şi lucrul cu numere complexe, care sa aiba:
- date membru: elemente necesare pentru memorarea partii reale şi a celei imaginare a unui numar complex;
- functii membru pentru memorarea datelor într-un numar complex, calculul modulului, afişarea unui numar complex şi suma, respectiv, produsul între doua numere complexe.
Se cere existenta unui constructor explicit de initializare şi al unuia de copiere (transfer de date). (rezolvare...)

2) Sa se implementeze operatiile pe o stiva statica. Pentru aceasta vom declara o clasa SStiva şi metode pentru fiecare operatie : definirea clasei, implementarea metodelor definite, folosirea clasei SStiva (rezolvare...)

Rezolvari

#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;
 
class complex
{
	float a,b; //a - partea reala, b - partea imaginara
	public:
	void atribuire(float=0,float=0);
	void citire();
	float& retre();
	float& retim();
	complex(float,float);
	complex(){}
	complex(complex&);
	void afisare(char*);
	float modul();
 
	//SUMAREA A DOUA NUMERE COMPLEXE PRIN MAI MULTE VARIANTE
	//1. cu transmitere prin tipul rezultat
	complex suma1(complex); /*un nr. complex este cel transmis prin
	obiectul curent, al doilea nr. complex este cel transmis prin
	parametru*/
 
	//2. cu transmitere prin linia de parametri - transfer prin adresa
	void suma2(complex,complex*);
 
	/*3. cu transmitere prin linia de parametri - transfer prin
	referinta*/
	void suma3(complex,complex&);
 
	//PRODUSUL A DOUA NUMERE COMPLEXE
	complex produs(complex);
};
 
void complex::atribuire(float x, float y)
{
	a=x; b=y;
}
 
void complex::citire()
{
	cout<<"\partea reala: ";
	cin>>a;
	cout<<"\partea imaginara: ";
	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::afisare(char* s)
{
	cout<<"Numarul complex "<<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));
}
	/*se va realiza sumarea intre nr. complex reprezentat prin obiectul
	curent, cel care va apela functia, si nr. complex transmis prin
	obiectul cu numele "z" din linia de parametri*/
 
complex complex::suma1(complex z)
{
	complex r;
	r.a=a+z.a;
	r.b=b+z.b;
	return r;
}
 
void complex::suma2(complex z,complex* r)
{
	r->a=a+z.a;
	r->b=b+z.b;
}
 
void complex::suma3(complex z,complex& r)
{
	r.a=a+z.a;
	r.b=b+z.b;
}
 
complex complex::produs(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.vom introduce date intr-un numar complex folosind functia de
	atribuire*/
	complex z1; /*apel al constrctorului de initializare fara parametri si
	fara corp definit*/
 
	int a,b; /*a nu se face confuzie: a si b de aici nu sunt cele din
	clasa, ptr ca acela fiind protejate nu putem avea acces la ele din
	afara clasei*/
 
	cout<<"Atribuim valori citite partilor reale si imaginare.\n";
	cout<<"\tpartea reala: ";
	cin>>a;
	cout<<"\tpartea imaginara: ";
	cin>>b;
	z1.atribuire(a,b);
 
	//2.vom introduce date intr-un numar complex prin citirea acestuia
	complex z2;
	cout<<"Citim un numar complex.\n";
	z2.citire();
 
	//3.introducere directa a valorilor partii reale, respectiv, imaginare
	complex z3;
	cout<<"Introducem direct pe partea reala si imaginara, date.\n";
	cout<<"\tpartea reala: ";
	cin>>z3.retre();
	int c;
	cout<<"\tpartea imaginara: ";
	cin>>c;
	z3.retim()=c; /*acest transfer este posibil datorita faptului ca
	functia intoarce o referinta*/
 
	/*4.introducere date in nr. complex prin intermediul constructorului
	de initializare cu parametri.*/
	cout<<"Am introdus date direct printr-un constructor de initializare.\n";
	complex z4(3,-2); /*valorile se pot da direct, sau, citite in
	prealabil*/
 
	//afisam nr. complexe
	z1.afisare("z1");
	z2.afisare("z2");
	z3.afisare("z3");
	z4.afisare("z4");
 
	//SUMA A DOUA NR. COMPLEXE
	complex s; //putem apela oricare din cele 3 functii de calcul a sumei
	z1.suma3(z2,s); //s=z1+z2
	s.afisare("z1+z2");
 
	//PRODUSUL A DOUA NR. COMPLEXE
	complex p;
	p=z1.produs(z2); //p=z1*z2
	p.afisare("z1*z2");
 
	int g;
	cin >>g;
}

#include <iostream>
#include <fstream>
#include <math.h>
#define dim 20
using namespace std;
class Sstiva
{
	int s[dim];
	int vf; //varful stivei
	public:
	Sstiva();
	~Sstiva();
	void Push(int e); //introduce elementul e in stiva
	int Pop(); //extrage un element din stiva. Se aplica tehnica LIFO
	int Lungime() //returneaza marimea stivei
	{
		return vf;
	}
	int Elem(int index); //returneaza elementul de pe un anumit index
	void Afisare();
};
Sstiva::Sstiva(void)
{
	vf=0;
	cout<<"Stiva initializata."<<endl;
}
Sstiva::~Sstiva(void)
{
	if(vf==0)
	cout<<"Stiva distrusa."<<endl;
}
void Sstiva::Push(int e)
{
	if(vf==dim)
	{
		cout<<"Stiva este plina."<<endl;
		return; //se face iesire fortata din functie
	}
	s[vf]=e;
	vf++;
}
int Sstiva::Pop(void)
{
	if(vf==0)
	{
		cout<<"Stiva depasita"<<endl;
		return 0;
	}
	vf--;
	return s[vf];
}
int Sstiva::Elem(int index)
{
	return s[index-1];
}
void Sstiva::Afisare()
{
	if(vf)
	{
		for(int i=0;i<vf;i++)
		cout<<s[i]<<" ";
		cout<<endl;
		return;
	}
}
void main()
{
	Sstiva ob;
	int e; //variabila care retine variabilele introduse in stiva
	do
	{
		cout<<"Dati elementul (-1=scoate, 0=stop): ";
		cin>>e;
		if(e)
		if(e!=(-1))
		{
			ob.Push(e);
			ob.Afisare();
			cout<<"Dimensiunea stivei este: "<<ob.Lungime()<<endl;
		}
		else
		{
			ob.Pop();
			ob.~Sstiva();
			ob.Afisare();
		}
	} while(e);
 
	int g;
	cin >>g;
}
COMENTARII

optional (nu va fi afisat pe website)
max: 255 caractere


Acest site utilizeaza cookie-uri. Navigand in continuare va exprimati acordul asupra folosirii cookie-urilor.