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; }