T. O. Y. O. Together Open Youth Opportunities Education, Fraternity, Peace

C++: Operatii de intrare / iesire - aplicatii rezolvate

1) Sa se realizeze un program care realizeaza formatari utilizând indicatorii de formatare (rezolvare...)

2) Sa se realizeze un program care realizeaza formatari utilizând manipulatorii de formatare (rezolvare...)

3) Sa se realizeze un program care prin intermediul unui constructor populeaza datele într-o agenda de telefon iar prin supraîncarcarea operatorului << face ieşirea datelor pe ecran (rezolvare...)

4) Sa se realizeze un program care prin intermediul unui constructor populeaza datele într-o agenda de telefon iar prin supraîncarcarea operatorului << face ieşirea datelor pe ecran, astfel încât sa lucram cu date protejate (rezolvare...)

5) Sa se refaca exemplul anterior astfel încât datele sa nu mai fie introduse prin intermediul unui constructor, ci printr-o functie care supraîncarca operatorul >> (rezolvare...)

6) Sa se descrie un tip abstract de date pentru memorarea unui numar complex si principalele operatii cu aceste numere prin supraincarcari de operatori (rezolvare...)

7) Sa se realizeze o aplicatie pentru lucrul cu numere rationale (numim numar rational orice numar ce poate fi scris sub forma de fractie). Se vor folosi operatori supraîncarcati (rezolvare...)

Rezolvari

1) Sa se realizeze un program care realizeaza formatari utilizând indicatorii de formatare.

#include <iostream>
#include <fstream>
#include <math.h>
#include<conio.h>
using namespace std;
 
void main()
{
	int n=123;
 
	//1. se afiseaza 00123
	cout.width(5);
	cout.setf(ios::right,ios::adjustfield);
	cout.fill('0');
	cout<<n;
	cout<<"\nActionati pentru a continua.\n";
	getch();
 
	//2. se afiseaza +1230
	cout.width(5);
	cout.fill('0');
	cout.setf(ios::left,ios::adjustfield);
	cout.setf(ios::showpos);
	cout<<n;
	cout<<"\nActionati pentru a continua.\n";
	getch();
 
	//3. se afiseaza +0123 (semnul plus ramane activat)
	cout.width(5);
	cout.fill('0');
	cout.setf(ios::internal,ios::adjustfield);
	cout<<n;
	cout<<"\nActionati pentru a continua.\n";
	getch();
 
	//4. afiseaza valoarea in hexazecimal a numarului n
	cout.setf(ios::hex,ios::basefield); //oct ptr. afisare in octal
	cout<<n;
	cout<<"\nActionati pentru a continua.\n";
	getch();
	double d=123.456;
 
	//5. se afiseaza in forma stiintifica numarul d
	cout.unsetf(ios::showpos); //dezactivam optiunea de afisare cu +
	cout.setf(ios::scientific,ios::floatfield);
	cout<<d;
	cout<<"\nActionati pentru a continua.\n";
	getch();
 
	//6. se afiseaza cu o precizie de 2 cifre
	cout.setf(ios::fixed,ios::floatfield);
	cout.precision(2);
	cout<<d;
	cout<<"\nActionati pentru a continua.\n";
	getch();
 
	int g;
	cin >>g;
}

2) Sa se realizeze un program care realizeaza formatari utilizând manipulatorii de formatare.

#include<iostream>
#include<conio.h>
#include<iomanip>
using namespace std;
 
void main()
{
	int n=123;
 
	//1. afiseaza 00123
	cout<<setw(5)<<setiosflags(ios::right)<<setfill('0')<<n;
	cout<<"\nActionati o tasta pentru a continua.\n";
	getch();
 
	//2. se afiseaza +1230
	cout<<setw(5)<<setiosflags(ios::left)<<setfill('0')<<
	setiosflags(ios::showpos)<<n;
	cout<<"\nActionati o tasta pentru a continua.\n";
	getch();
 
	//3. se afiseaza +0123 (semnul plus ramane activat)
	cout<<setw(5)<<setiosflags(ios::internal)<<setfill('0')<<n;
	cout<<"\nActionati o tasta pentru a continua.\n";
	getch();
 
	//4. se afiseaza numarul in hexazecimal
	cout<<hex<<n;
	cout<<"\nActionati o tasta pentru a continua.\n";
	getch();
	double d=123.456;
 
	//5. se afiseaza in forma stiintifica
	cout<<resetiosflags(ios::fixed)<<
	setiosflags(ios::scientific)<<d;
	cout<<"\nActionati o tasta pentru a continua.\n";
	getch();
 
	//6. se afiseaza cu o precizie de 2 cifre
	cout<<setprecision(2)<<d;
	cout<<"\nActionati o tasta pentru a continua.\n";
	getch();
 
	int g;
	cin >>g;
}

3) Sa se realizeze un program care prin intermediul unui constructor populeaza datele într-o agenda de telefon iar prin supraîncarcarea operatorului << face ieşirea datelor pe ecran.

#include <iostream>
#include<string.h>
#include<conio.h>
using namespace std;
 
class agendatelefon {
	public:
	char nume[20];
	int codzona;
	int prefix;
	unsigned long int numar;
 
	agendatelefon(char *n,int a,int p,unsigned long int nr)
	{
		strcpy(nume,n);
		codzona=a;
		prefix=p;
		numar=nr;
	}
};
 
//Afiseaza numele si numarul de telefon
ostream &operator<<(ostream &stream, agendatelefon a)
{
	stream<<a.nume;
	stream<<"("<<a.codzona<<")";
	stream<<a.prefix<<"-"<<a.numar<<"\n";
	return stream;
}
 
void main()
{
	agendatelefon a("Ioan",40,269,244573);
	agendatelefon b("Elena",40,264,789045);
	cout<<a<<b;
	getch();
 
	int g;
	cin >>g;
}

4) Sa se realizeze un program care prin intermediul unui constructor populeaza datele într-o agenda de telefon iar prin supraîncarcarea operatorului << face ieşirea datelor pe ecran, astfel încât sa lucram cu date protejate.

#include <iostream>
#include<string.h>
#include<conio.h>
using namespace std;
 
class agendatelefon {
	char nume[20];
	int codzona;
	int prefix;
	unsigned long int numar;
	public:
	agendatelefon(char *n,int a,int p,unsigned long int nr)
	{
		strcpy(nume,n);
		codzona=a;
		prefix=p;
		numar=nr;
	}
 
	//Afiseaza numele si numarul de telefon
	friend ostream &operator<<(ostream &stream, agendatelefon a)
	{
		stream<<a.nume;
		stream<<"("<<a.codzona<<")";
		stream<<a.prefix<<"-"<<a.numar<<"\n";
		return stream;
	}
};
 
void main()
{
	agendatelefon a("Ioan",40,269,244573);
	agendatelefon b("Elena",40,264,789045);
	cout<<a<<b;
	getch();
 
	int g;
	cin >>g;
}

5) Sa se refaca exemplul anterior astfel încât datele sa nu mai fie introduse prin intermediul unui constructor, ci printr-o functie care supraîncarca operatorul >>.

#include<iostream>
#include<string.h>
#include<conio.h>
using namespace std;
 
class agendatelefon {
	char nume[20];
	int codzona;
	int prefix;
	unsigned long int numar;
	public:
	agendatelefon()
	{
	}
 
	//Afiseaza numele si numarul de telefon
	friend ostream &operator<<(ostream &stream, agendatelefon a);
 
	//Introduce numele si numarul de telefon
	friend istream &operator>>(istream &stream, agendatelefon &a);
};
 
//Afiseaza numele si numarul de telefon
ostream &operator<<(ostream &stream, agendatelefon a)
{
	stream<<strupr(a.nume)<<'\t';
	stream<<"("<<a.codzona<<")";
	stream<<a.prefix<<"-"<<a.numar<<"\n";
	return stream;
}
 
//Introduce numele si numarul de telefon
istream &operator>>(istream &stream, agendatelefon &a)
{
	cout<<"Introduceti nume: ";
	stream>>a.nume;
	cout<<"Introduceti codzona: ";
	stream>>a.codzona;
	cout<<"Introduceti prefix: ";
	stream>>a.prefix;
	cout<<"Introduceti numar: ";
	stream>>a.numar;
	cout<<"\n";
	return stream;
}
void main()
{
	agendatelefon a;
	cin>>a;
	cout<<a;
	getch();
 
	int g;
	cin >>g;
}

6) Sa se descrie un tip abstract de date pentru memorarea unui numar complex si principalele operatii cu aceste numere prin supraincarcari de operatori.

#include <iostream>
#include<string.h>
#include<conio.h>
#include<math.h>
#include<iomanip> /*biblioteca folosita pentru manipulatorii
 cu parametru, in cazul acestei aplicatii: functia setprecision*/
using namespace std;
 
class complex
{
	float a,b; //in 'a' memoram partea reala, in 'b' memoram partea imaginara
	public:
	complex(float=0,float=0); //constructor de initializare cu parametri
	float& retre(); //returneaza partea reala
	float& retim(); //returneaza partea imaginara
	complex operator+(complex&); //adunarea a doua numere complexe
	complex operator-(); //negativul (opusul) unui numar complex
	complex operator-(complex&); /*diferenta intre doua numere complexe*/
	complex operator~(); //conjugatul unui numar complex
	complex operator*(complex&); //produsul a doua numere complexe
	double operator!(); //modulul unui numar complex
	complex operator *(float); //multiplicarea unui nr. complex cu un scalar
	friend complex operator*(float,complex&); /*operatia inversa celei anterioare, 
						adica, scalar inmultit cu nr. complex*/
	friend istream& operator>>(istream&,complex&); /*supraircarea
			operatorului de extragere din flux ptr. citirea unui nr. complex*/
	friend ostream& operator<<(ostream&,complex); /*supraincarcarea
			operatorului de insertie in flux ptr. afisarea unui nr. complex*/
};
 
inline complex::complex(float x,float y)
{
	a=x;
	b=y;
}
 
inline float& complex::retre()
{
	return a;
}
 
inline float& complex::retim()
{
	return b;
}
complex complex::operator+(complex& z)
{
	complex r;
	r.a=a+z.a;
	r.b=b+z.b;
	return r;
}
 
complex complex::operator-()
{
	complex r;
	r.a=-a;
	r.b=-b;
	return r;
}
 
complex complex::operator-(complex& z)
{
	return (*this)+(-z); /*relatie intre obiectul curent si cel transmis ca parametru, 
	operatorii din relatie fiind cei supraincarcati prin functiile anterioare*/
}
 
complex complex::operator~()
{
	complex r;
	r.a=a;
	r.b=-b;
	return r;
}
 
complex complex::operator*(complex& z)
{
	complex r;
	r.a=a*z.a-b*z.b;
	r.b=a*z.b+b*z.a;
	return r;
}
 
double complex::operator!()
{
	return sqrt(pow(a,2)+pow(b,2));
}
 
complex complex::operator*(float x)
{
	complex r;
	r.a=x*a;
	r.b=x*b;
	return r;
}
 
complex operator*(float x, complex& z)
{
	return z*x; //operator supraincarcat anterior
}
 
istream& operator>>(istream& c, complex& z)
{
	cout<<"\tdati partea reala: ";
	c>>z.a;
	cout<<"\tdati partea imaginara: ";
	c>>z.b;
	return c;
}
 
ostream& operator<<(ostream& c, complex z)
{
	c<<"nr. complex este: "<<setprecision(2)<<z.a; /*se vor afisa 
		2 zecimale dupa virgula, doar acolo unde e cazul*/
	cout.setf(ios::showpos);
	c<<' '<<z.b<<"*i"<<endl;
	cout.unsetf(ios::showpos);
	return c;
}
 
void main()
{
	complex z1,z2; /*printr-o astfel de declaratie partile reale si 
				   cele imaginare sunt completate cu 0*/
	cout<<"Citim z1."<<endl;
	cin>>z1; //apel al operatorului extragere din flux supraincarcat
	cout<<"Memoram date direct in z2."<<endl;
	z2.retre()=4;
	z2.retim()=-1;
	cout<<endl;
	cout<<"Nr. complex z1 - "<<z1; /*apel al functiei ce supraincarca
					operatorul de insertie in flux*/
	cout<<"Nr. complex z2 - "<<z2;
	cout<<endl;
	cout<<"Suma z1+z2 - "<<z1+z2; /*apel al functiilor ce supraincarca
					operatorii: '+' si insertie in flux*/
	cout<<"Produsul z1*z2 - "<<z1*z2; /*apel al functiilor ce supraincarca
					operatorii: '*' si insertie in flux*/
	cout<<"Modulul sumei este: "<<!(z1+z2)<<endl; /*apel al functiilor ce
					supraincarca operatorii '+' si '!'*/
	complex z3;
	z3=(~z1)+(2*(-z2)*(!z1)); //sunt folositi mai multi operatori supraincarcati din lista
	cout<<"Expresia (~z1)+(2*(-z2)*(!z1)) - "<<z3;
 
	int g;
	cin >>g;
}

7) Sa se realizeze o aplicatie pentru lucrul cu numere rationale (numim numar rational orice numar ce poate fi scris sub forma de fractie). Se vor folosi operatori supraîncarcati.

#include<iostream>
#include<fstream>
#include<string.h>
#include<conio.h>
#include<math.h>

using namespace std;
 
class rational
{
	int a; //numaratorul fractiei
	int b; //numitorul fractiei
int cmmdc(int,int); /*cmmdc-ul a doua nr. intregi folosit la determinarea fractiilor ireductibile*/
	void ireductibil(); //determinarea unei fractii ireductibile
	public:
	rational(int=0,int=1); //constructor de initializare cu parametri impliciti
	int& retnumarator(); //functie ce returneaza numaratorul fractiei
	int& retnumitor(); //functie ce returneaza numitorul fractiei
friend istream& operator>>(istream&, rational&); /*citirea unui numar rational*/
friend ostream& operator<<(ostream&, rational); /*afisarea unui numar rational*/
	rational operator+(rational&); //adunarea a doua nr. rationale
	rational operator-(); //opusul unui numar rational
	rational operator-(rational&); //diferenta a doua nr. rationale
	rational operator*(rational&); //inmultirea a doua nr. rationale
	rational operator*(int); //inmultirea unui nr. complex cu un scalar
friend rational operator*(int, rational&); /*inmultirea unui scalar cu un nr. complex*/
	rational operator!(); //inversul unui numar rational
	rational operator/(rational&); //impartirea a doua nr. rationale
};
 
/*cmmdc-ul a doua nr. intregi folosit la determinarea fractiilor ireductibile - am ales varianta iterativa*/
 
int rational::cmmdc(int x,int y)
{
	x=abs(x);
	y=abs(y);
	while(x!=y)
	if(x>y)
		x-=y; //x=x-y;
	else
		y-=x; //y=y-x;
	return x;
}
 
/*determinarea unei fractii ireductibile*/
void rational::ireductibil()
{
	if(a==0) b=1;
	else
		{
			if((abs(a)!=1)&&(abs(b)!=1))
			{
				int d;
				d=cmmdc(a,b);
				a/=d; //a=a/d;
				b/=d; //b=b/d;
			}
		if(b<0)
		{
			a=-a;
			b=-b;
		}
	}
}
 
/*constructor de initializare cu parametri*/
inline rational::rational(int x,int y)
{
	a=x;
	b=y;
	ireductibil();
}
 
/*functie ce returneaza numaratorul fractiei*/
inline int& rational::retnumarator()
{
	return a;
}
 
/*functie ce returneaza numitorul fractiei*/
inline int& rational::retnumitor()
{
	return b;
}
 
/*supraincarcarea operatorului de extragere 
din flux pentru citirea unui numar rational*/
 
istream& operator>>(istream& in, rational& r)
{
	cout<<"\tintroduceti numaratorul: ";
	in>>r.a;
	do{
		cout<<"\tintroduceti numitorul: ";
		in>>r.b;
	}while(r.b==0); //numitorul diferit de 0
	r.ireductibil();
	return in;
}
 
/*supraincarcarea operatorului de insertie in flux 
pentru afisarea unui numar rational*/
 
ostream& operator<<(ostream& out, rational r)
{
	out<<r.a<<"/"<<r.b;
	return out;
}
 
/*supraincarcarea operatorului '+' pentru adunarea a doua numere rationale*/
rational rational::operator+(rational& r)
{
	rational p;
	p.a=a*r.b+b*r.a;
	p.b=b*r.b;
	p.ireductibil();
	return p;
}
 
/*supraincarcarea operatorului '-' pentru determinarea opusului unui numar rational*/
rational rational::operator-()
{
	rational p;
	p.a=-a;
	p.b=-b;
	p.ireductibil(); /*la prima vedere pare inutil aici al acestei functii, dar, 
	am optat pentru asta mizand faptul ca nu cunoastem operatiile de populare a 
	datelor unui numar rational, daca prin intermediul acestora s-a apelat 
	procedura de determinare a unei fractii ireductibile*/
	return p;
}
 
/*supraiuncarcarea operatorului '-' pentru diferenta a doua numare rationale*/
rational rational::operator-(rational& r)
{
	rational p;
	p=(*this)+(-r); //apel al celor doua functii definite anterior
	p.ireductibil();
	return p;
}
 
/*supraincarcarea operatorului '*' pentru inmultirea a doua numere rationale*/
rational rational::operator*(rational& r)
{
	rational p;
	p.a=a*r.a;
	p.b=b*r.b;
	p.ireductibil();
	return p;
}
 
/*supraincarcarea operatorului '*' pentru inmultirea unui nr. rational
 cu un numar intreg*/
rational rational::operator*(int x)
{
	rational p;
	p.a = a*x; //sau: x*a;
	p.b = b*x; //sau: x*b;
	p.ireductibil();
	return p;
}
 
/*supraincarcarea operatorului '*' pentru inmultirea unui numar intreg 
cu unul rational*/
rational operator*(int x, rational r)
{
	return r*x; //apel al functiei dezvoltate anterior
}
 
/*supraincarcarea operatorului '!' pentru inversul unui numar rational*/
rational rational::operator!()
{
	rational p;
	p.a=b;
	p.b=a;
	p.ireductibil();
	return p;
}
 
/*supraincarcarea operatorlui '/' pentru impartirea a doua numere rationale*/
rational rational::operator/(rational& r)
{
	rational p;
	p=(*this)*(!r);
	p.ireductibil();
	return p;
}
 
void main()
{
	rational a(4,-2);
	cout<<"Primul numar rational este introdus prin functia constructor."<<endl;
	rational b;
	cout<<"Introduceti date ptr al doilea nr. rational:"<<endl;
	cin>>b;
	cout<<"Primul numar rational este: "<<a<<endl;
	cout<<"Al doilea numar rational este: "<<b<<endl;
	cout<<endl<<"-----------------------------------"<<endl;
	cout<<"Adunarea celor doua numere este: "<<a+b<<endl;
	cout<<"Inmultirea celor doua numere este: "<<a*b<<endl;
	cout<<"Impartirea celor doua numere este: "<<a/b<<endl;
 
	int g;
	cin >>g;
}