Opérations Entrée/Sortie en C++ - Applications résolues


1) Realiser un programme qui fait des formatées en utilisant les indicateurs de formatation.
#include <iostream>
#include <fstream>
#include <math.h>
#include<conio.h>
using namespace std;
 
void main()
{
	int n=123;
 
	//1. afficher 00123
	cout.width(5);
	cout.setf(ios::right,ios::adjustfield);
	cout.fill('0');
	cout<<n;
	cout<<"\nActioner pour continuer.\n";
	getch();
 
	//2. on affiche +1230
	cout.width(5);
	cout.fill('0');
	cout.setf(ios::left,ios::adjustfield);
	cout.setf(ios::showpos);
	cout<<n;
	cout<<"\nActioner pour continuer.\n";
	getch();
 
	//3. on affiche +0123 (le signe plus reste actif)
	cout.width(5);
	cout.fill('0');
	cout.setf(ios::internal,ios::adjustfield);
	cout<<n;
	cout<<"\nActioner pour continuer.\n";
	getch();
 
	//4. afficher la valeur en hexadecimal du nombre n
	cout.setf(ios::hex,ios::basefield); //oct pour afficher en octal
	cout<<n;
	cout<<"\nActioner pour continuer.\n";
	getch();
	double d=123.456;
 
	//5. afficher dans la forme sciantifique le nombred
	cout.unsetf(ios::showpos); //dezactivation d’affichage avec +
	cout.setf(ios::scientific,ios::floatfield);
	cout<<d;
	cout<<"\nActioner pour continuer.\n";
	getch();
 
	//6. afficher avec une precision de 2 ciffres
	cout.setf(ios::fixed,ios::floatfield);
	cout.precision(2);
	cout<<d;
	cout<<"\nActioner pour continuer.\n";
	getch();
 
	int g;
	cin >>g;
}

2) Faire un programme qui realise des formates en utilisant manipulateurs de formatation.
#include<iostream>
#include<conio.h>
#include<iomanip>
using namespace std;
 
void main()
{
	int n=123;
 
	//1. affichera 00123
	cout<<setw(5)<<setiosflags(ios::right)<<setfill('0')<<n;
	cout<<"\nActioner une taste pour continuer.\n";
	getch();
 
	//2. afficher +1230
	cout<<setw(5)<<setiosflags(ios::left)<<setfill('0')<<
	setiosflags(ios::showpos)<<n;
	cout<<"\nActioner une taste pour continuer.\n";
	getch();
 
	//3. afficher +0123 (le signe plus reste actif)
	cout<<setw(5)<<setiosflags(ios::internal)<<setfill('0')<<n;
	cout<<"\nActioner une taste pour continuer.\n";
	getch();
 
	//4. afficher le nombre en xehadecimal
	cout<<hex<<n;
	cout<<"\nActioner une taste pour continuer.\n";
	getch();
	double d=123.456;
 
	//5. afficher dans la forme sciantifique
	cout<<resetiosflags(ios::fixed)<<
	setiosflags(ios::scientific)<<d;
	cout<<"\nActioner une taste pour continuern";
	getch();
 
	//6. afficher avec une precision de 2 ciffres
	cout<<setprecision(2)<<d;
	cout<<"\nActioner une taste pour continuer.\n";
	getch();
 
	int g;
	cin >>g;
}

3) Realiser un programme qui par l’intermede d’un constructeur popule les dates dans une agende de telephone et par surcharge de l’opperateur << fait sortir les dates sur l’ecran.
#include <iostream>
#include<string.h>
#include<conio.h>
using namespace std;
 
class annuaire {
	public:
	char nom[20];
	int codzona;
	int prefix;
	unsigned long int nombre;
 
	annuaire(char *n,int a,int p,unsigned long int nr)
	{
		strcpy(nom,n);
		codzona=a;
		prefix=p;
		nombre=nr;
	}
};
 
//afficher le nom et le nombre de telephone
ostream &operator<<(ostream &stream, annuaire a)
{
	stream<<a.nom;
	stream<<"("<<a.codzona<<")";
	stream<<a.prefix<<"-"<<a.nombre<<"\n";
	return stream;
}
 
void main()
{
	annuaire a("Ioan",40,269,244573);
	annuaire b("Elena",40,264,789045);
	cout<<a<<b;
	getch();
 
	int g;
	cin >>g;
}

4) Realiser un programme qui par l’intermede d’un constructeur popule les dates dans une agende de telephone et par surcharge de l’opperateur << fait sortir les dates sur l’ecran pour travailler avec des dates protegés.
#include <iostream>
#include<string.h>
#include<conio.h>
using namespace std;
 
class annuaire {
	char nom[20];
	int codzona;
	int prefix;
	unsigned long int nombre;
	public:
	annuaire(char *n,int a,int p,unsigned long int nr)
	{
		strcpy(nom,n);
		codzona=a;
		prefix=p;
		nombre=nr;
	}
 
	//afficher le nom et le nombre de telephone
	friend ostream &operator<<(ostream &stream, annuaire a)
	{
		stream<<a.nom;
		stream<<"("<<a.codzona<<")";
		stream<<a.prefix<<"-"<<a.nombre<<"\n";
		return stream;
	}
};
 
void main()
{
	annuaire a("Ioan",40,269,244573);
	annuaire b("Elena",40,264,789045);
	cout<<a<<b;
	getch();
 
	int g;
	cin >>g;
}

5) Refaire l’exemple enterieur pour introduire les dates par une fonction qui suscharge l’opperateur >>.
#include<iostream>
#include<string.h>
#include<conio.h>
using namespace std;
 
class annuaire {
	char nom[20];
	int indicatif;
	int prefixe;
	unsigned long int nombre;
	public:
	annuaire()
	{
	}
 
	//afficher le nom et le nombre de telephone
	friend ostream &operator<<(ostream &stream, annuaire a);
 
	//Introduire le nom et le nombre de telephone
	friend istream &operator>>(istream &stream, annuaire &a);
};
 
//Afficher le nom et le nombre de telephone
ostream &operator<<(ostream &stream, annuaire a)
{
	stream<<strupr(a.nom)<<'\t';
	stream<<"("<<a.indicatif<<")";
	stream<<a.prefixe<<"-"<<a.nombre<<"\n";
	return stream;
}
 
//Introduire le nom et le nombre de telephone
istream &operator>>(istream &stream, annuaire &a)
{
	cout<<"Introduire le nom: ";
	stream>>a.nom;
	cout<<"Introduire le code et la zone: ";
	stream>>a.indicatif;
	cout<<"Introduire le prefixe: ";
	stream>>a.prefixe;
	cout<<"Introduire le nombre: ";
	stream>>a.nombre;
	cout<<"\n";
	return stream;
}
void main()
{
	annuaire a;
	cin>>a;
	cout<<a;
	getch();
 
	int g;
	cin >>g;
}

6) Decrire un type abstrait de dates pour memoriser un nombre complexe et Les principles operations avec ces nombres par surcharge d’operateurs.
#include <iostream>
#include<string.h>
#include<conio.h>
#include<math.h>
#include<iomanip> /*bibliotheque pour manipulateurs
 Avec parametre, dans cette application: fonction setprecision*/
using namespace std;
 
class complexe
{
	float a,b; //dans 'a' memoriser la partie reelle, dans 'b' memoriser la partie imaginaire
	public:
	complexe(float=0,float=0); //constructeur d’initialisation avec parametres
	float& retre(); //retourne la partie reelle
	float& retim(); //retourne la partie imaginaire
	complexe operator+(complexe&); //addition de deux nombres complexees
	complexe operator-(); //negatif (l’oposé) d’un nombre comnplexe
	complexe operator-(complexe&); /*difference entre deux nombres complexees*/
	complexe operator~(); //conjuqué d’un nombre complexee
	complexe operator*(complexe&); //produit de deux nombres complexeex
	double operator!(); //module d’un nombre complexee
	complexe operator *(float); //multiplication d’un nombre complexee avec un scalaire
	friend complexe operator*(float,complexe&); /*multiplication d’un scalaire avec un nombre complexee*/
	friend istream& operator>>(istream&,complexe&); /*surcharge d’opperateur d’extraction du fluxe  pour 
							lire un nombre complexee */
	friend ostream& operator<<(ostream&,complexe); /*surcharge operateur d’insertion 
							en fluxe pour afficher un nombre complexee*/
};
 
inline complexe::complexe(float x,float y)
{
	a=x;
	b=y;
}
 
inline float& complexe::retre()
{
	return a;
}
 
inline float& complexe::retim()
{
	return b;
}
complexe complexe::operator+(complexe& z)
{
	complexe r;
	r.a=a+z.a;
	r.b=b+z.b;
	return r;
}
 
complexe complexe::operator-()
{
	complexe r;
	r.a=-a;
	r.b=-b;
	return r;
}
 
complexe complexe::operator-(complexe& z)
{
	return (*this)+(-z); /*relation entre l’objet courent si celui transmis comme parametre, 
			les operateurs de relation sont surcharges par les fonctions anterieures*/
}
 
complexe complexe::operator~()
{
	complexe r;
	r.a=a;
	r.b=-b;
	return r;
}
 
complexe complexe::operator*(complexe& z)
{
	complexe r;
	r.a=a*z.a-b*z.b;
	r.b=a*z.b+b*z.a;
	return r;
}
 
double complexe::operator!()
{
	return sqrt(pow(a,2)+pow(b,2));
}
 
complexe complexe::operator*(float x)
{
	complexe r;
	r.a=x*a;
	r.b=x*b;
	return r;
}
 
complexe operator*(float x, complexe& z)
{
	return z*x; //operateur surcharge anterieurement
}
 
istream& operator>>(istream& c, complexe& z)
{
	cout<<"\tdonnez la partie reelle: ";
	c>>z.a;
	cout<<"\tdonnez la partie imaginaire: ";
	c>>z.b;
	return c;
}
 
ostream& operator<<(ostream& c, complexe z)
{
	c<<"nombre complexee est: "<<setprecision(2)<<z.a; /*afficher 2 decimales apres virgule, si c’est le cas*/
	cout.setf(ios::showpos);
	c<<' '<<z.b<<"*i"<<endl;
	cout.unsetf(ios::showpos);
	return c;
}
 
void main()
{
	complexe z1,z2; /*dans une telle declaration, les parties reelles 
			et imaginaires se completent avec 0*/
	cout<<"Lire z1."<<endl;
	cin>>z1; //appel de l’operateur d’extraction du fluxe surchargé
	cout<<"Memorizer les dates en z2."<<endl;
	z2.retre()=4;
	z2.retim()=-1;
	cout<<endl;
	cout<<"Nombre complexe z1 - "<<z1; /*appel de fonction qui surcharge
					l’operateur d’insertion en fluxe*/
	cout<<"Nombre complexe z2 - "<<z2;
	cout<<endl;
	cout<<"Suma z1+z2 - "<<z1+z2; /*appel des fonctiones qui surchargent
					les operateurs: '+' et insertion en fluxe*/
	cout<<"Produit z1*z2 - "<<z1*z2; /*appel des fonctions qui surchargent
					les operateurs: '*' et insertion en fluxe*/
	cout<<"Module de somme est: "<<!(z1+z2)<<endl; /*appel des fonctions qui
					surchargent les operateurs '+' et '!'*/
	complexe z3;
	z3=(~z1)+(2*(-z2)*(!z1)); //on utilise de plus les operateurs surcharges de la liste
	cout<<"Expression (~z1)+(2*(-z2)*(!z1)) - "<<z3;
 
	int g;
	cin >>g;
}

7) Realiser une aplication pour travail avec les nombres rationels (nombre rationel c’est tout nombre qui peut etre ecrit sous la forme de fraction). On va utiliser les operateurs surcharges.
#include<iostream>
#include<fstream>
#include<string.h>
#include<conio.h>
#include<math.h>

using namespace std;
 
class rationnel
{
	int a; //numerateur de la fraction
	int b; //denominateur de fraction
int cmmdc(int,int); /*cmmdc de deux nombres entiers qu’on utilise pour determiner les fractions ireductibles*/
	void irreductible(); //determination d’;une fraction ireductible
	public:
	rationnel(int=0,int=1); //constructeur d’initialisation avec parametres implicits
	int& retnumerateur(); //fonction qui retourne le  numerateur de fraction
	int& retnumitor(); //fonction qui retourne le denominateur de fraction
friend istream& operator>>(istream&, rationnel&); /*lire un nombre rationel*/
friend ostream& operator<<(ostream&, rationnel); /*afficher un nombre rationel*/
	rationnel operator+(rationnel&); //addition de deux nombres rationels
	rationnel operator-(); //l’oposé d’un nombre rationel
	rationnel operator-(rationnel&); //difference de deux nombres rationels
	rationnel operator*(rationnel&); //multiplication de deux nombres rationels
	rationnel operator*(int); //multiplication d’un nombre complexe avec un scalaire
friend rationnel operator*(int, rationnel&); /*multiplication d’un scalaire avec un nombre complexe*/
	rationnel operator!(); //l’inverse d’un nombre rationel
	rationnel operator/(rationnel&); //divisation de deux nombres rationels
};
 
/*cmmdc de deux nombres entiers pour determiner les fractions ireductibles – version interative*/
 
int rationnel::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;
}
 
/*determiner une fraction ireductible*/
void rationnel::irreductible()
{
	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;
		}
	}
}
 
/*constructeur d’initialisation avec parametres*/
inline rationnel::rationnel(int x,int y)
{
	a=x;
	b=y;
	irreductible();
}
 
/*fonction qui retourne le numerateur de fraction*/
inline int& rationnel::retnumerateur()
{
	return a;
}
 
/*fonction qui retourne le denominateur de fraction*/
inline int& rationnel::retnumitor()
{
	return b;
}
 
/*surcharge d’operateur d’extraction 
De fluxe pour lire un nombre rationel*/
 
istream& operator>>(istream& in, rationnel& r)
{
	cout<<"\tintroduire le nombre: ";
	in>>r.a;
	do{
		cout<<"\tintroduire le numerateur: ";
		in>>r.b;
	}while(r.b==0); //denominateur different de 0
	r.irreductible();
	return in;
}
 
/*durcharge d’operateur d’insertion en fluxe 
Pour afficher un nombre rationel*/
 
ostream& operator<<(ostream& out, rationnel r)
{
	out<<r.a<<"/"<<r.b;
	return out;
}
 
/*surcharge d’operateur '+' pour l’adition de deux nombres rationels*/
rationnel rationnel::operator+(rationnel& r)
{
	rationnel p;
	p.a=a*r.b+b*r.a;
	p.b=b*r.b;
	p.irreductible();
	return p;
}
 
/*surcharge d’operateur '-' pour determiner l’oppose d’un nombre rationel*/
rationnel rationnel::operator-()
{
	rationnel p;
	p.a=-a;
	p.b=-b;
	p.irreductible(); /*cette fonction semble inutile, mais on ne connait 
			pas les operations de popularisation des dates d’un 
			nombre rationel, si par son intermede on appelle la 
			procedure de determiner une fraction ireductible*/
	return p;
}
 
/*surcharge d’operateur '-' pour la difference de deux nombres rationels*/
rationnel rationnel::operator-(rationnel& r)
{
	rationnel p;
	p=(*this)+(-r); //appel des deux fonctions anteieures
	p.irreductible();
	return p;
}
 
/*surcharge d’operateur '*' pour multiplication de deux nombres rationels*/
rationnel rationnel::operator*(rationnel& r)
{
	rationnel p;
	p.a=a*r.a;
	p.b=b*r.b;
	p.irreductible();
	return p;
}
 
/*surcharge d’operateur '*' pour multiplier un nombre rationel avec un nombre entier*/
rationnel rationnel::operator*(int x)
{
	rationnel p;
	p.a = a*x; //sau: x*a;
	p.b = b*x; //sau: x*b;
	p.irreductible();
	return p;
}
 
/*surcharge d’operateur '*' pour multiplier un nombre entierl avec l’un rationel */
rationnel operator*(int x, rationnel r)
{
	return r*x; //appel de la fonction anterieure
}
 
/*surcharge d’operateur '!' pour inverser un nombre rationel*/
rationnel rationnel::operator!()
{
	rationnel p;
	p.a=b;
	p.b=a;
	p.irreductible();
	return p;
}
 
/*surcharge d’operateur '/' pour diviser deux nombres rationels*/
rationnel rationnel::operator/(rationnel& r)
{
	rationnel p;
	p=(*this)*(!r);
	p.irreductible();
	return p;
}
 
void main()
{
	rationnel a(4,-2);
	cout<<"Le premier nombre rationel est introduit par la fonction constructeur."<<endl;
	rationnel b;
	cout<<"Introduire les dates pour le deuxieme nombre rationel:"<<endl;
	cin>>b;
	cout<<"Le premier nombre rationel est: "<<a<<endl;
	cout<<"Le deuxieme nombre rationel est: "<<b<<endl;
	cout<<endl<<"-----------------------------------"<<endl;
	cout<<"L’adition de deux nombres est: "<<a+b<<endl;
	cout<<"La multiplication de deux nombres est: "<<a*b<<endl;
	cout<<"La divisation de deux nombres est: "<<a/b<<endl;
 
	int g;
	cin >>g;
}
Cookies help us deliver our services. By using our services, you agree to our use of cookies.