Friday, July 12, 2013
Thursday, July 11, 2013
Chess is Almost Solved
Image credit: © 2013 Masterpiecegift.com.
“There are some things we do much better than computers, but since most of chess is tactically based they do many things better than humans. And this imbalance remains. I no longer have any issues. It’s a bit like asking an astronomer, does he mind that a
Credit: NASA
The Sun
The majority of stars in the galaxy, including our Sun, Sirius and Alpha Centauri A and B are all main sequence stars. The Sun's relative longevity and stability have provided the conditions necessary for life to evolve here on Earth. Our understanding of the processes involved and characteristics of this key group of stars has progressed in parallel with our understanding of nuclear physics.
Imagine
you were standing in the center of a circle 100 meters in radius. How
long do you think it would take to leave the circle? Usain Bolt could
do it in 10 seconds, but most people could leave the circle in under a
minute. After all, it’s just a casual 100 meter stroll and you are out
of the circle. But suppose we
In
the mid-1800s, astronomy faced a serious problem. No one knew how the
stars shone. Now a little mystery never hurt anyone, but in this case
it was deeply perplexing. By this time we had a solid understanding of
energy, and that energy is conserved. That is, energy must come from
somewhere, and it
In Medieval Europe, the physical universe could be divided into two parts: the Earth and earthly events (chaotic and temporary) and the heavens (structured and eternal). That's a bit of an over simplification, but the idea was that the Earth and heavens were governed by different rules. In the heavens the stars were fixed and eternal. The motion of the planets were thought to move in
Wednesday, July 10, 2013
 |  |  | |||||||||||
|
Stats
|
Sanity4J is primarily a tool for running multiple Java code static analysis tools.
Static Analysis tools are used to provide pointers to possible issues in code during the development cycle, as an automated form of code-review. Use of these tools helps to improve the quality of code and reduce the amount of software defects that are delivered for system testing.
Saturday, June 1, 2013
Lecture 14 (RC, RL and RLC AC circuits)
In this lecture complex numbers are used to analyse A.C. series circuits, in particular:
• Resistance Capacitance (RC) circuits
• Resistance (Pure) Inductance (RL) circuits
• Resistance (Pure) Inductance and Capacitance (RLC) circuits
• Resistance (Real) Inductance and Capacitance (RLC) circuits
• Resistance Capacitance (RC) circuits
• Resistance (Pure) Inductance (RL) circuits
• Resistance (Pure) Inductance and Capacitance (RLC) circuits
• Resistance (Real) Inductance and Capacitance (RLC) circuits
Thursday, May 30, 2013
Un hacheur alimente depuis une source de tension constante Ua une machine à courant
continu à aimants permanents. Les interrupteurssupposés parfaits commutent à une fréquence
fixe 1/T de 20kHz. Les couples d’interrupteurs(K1 K3) et (K2 K4) sont commandés de façon
complémentaire avec un rapport cyclique α.
CHAPITRE 1 :
COMPOSANTS POUR L’ELECTRONIQUE DE
PUISSANCE
Introduction :
On s’intéressera à la mise en évidence des caractéristiques des composants à semi
conducteurs utilisés dans les systèmes électroniques de puissance. On identifiera leurs
principales caractéristiques et les conventions simplificatrices permettant l’analyse des
montages fondamentaux : Redresseurs, Hacheurs, Gradateurs et Onduleurs.
Ces montages constituent ce que l’on appelle les convertisseurs statiques. Ce sont des
systèmes électroniques permettant le transfert de l’énergie depuis un réseau d’alimentation vers
un récepteur. Le but étant de pouvoir changer la forme de transfert de cette énergie :
Sous tension continue fixe.
Sous tension continue variable.
Sous tension alternative à valeur efficace fixe et fréquence fixe.
Sous tension alternative à valeur efficace fixe et fréquence variable.
…..etc.
Le principe d’un convertisseur statique obéit à la configuration suivante :
Download
Download
2.1 Introduction
La commande de vitesse des moteurs constitue l’application la plus importante de l’électronique de puisssance. Les installations industrielles utilisent de plus en plus des variateurs électroniques de vitesse à thyristors, soit pour obtenir la vitesse d’entraînement optimale de machines pour
Wednesday, April 24, 2013
61712 Primes et gratifications
61713 Indemnités et avantages divers
61714 Commissions au personnel
61715 Rémunérations des administrateurs, gérants et associés
6174 Charges sociales
61741 Cotisations de sécurité sociale
61742 Cotisations aux caisses de retraite
61743 Cotisations aux mutuelles
61744 Prestations familiales
61745 Assurances accidents
Tuesday, February 5, 2013
Algorithmique
Exercice 1 :
Ecrire un algorithme qui demande les coordonnées de deux points dans le plan, calcule et affiche à l’écran la distance entre ces deux points.
N.B.
la distance entre deux points A(x1,y1) et B(x2,y2) est : AB= sqrt((x2-x1)^2 + (y2-y1)^2)
on donne la fonction sqrt(x) qui renvoie la racine carrée d’un nombre réel x .
Langage C++
La surcharge des
opérateurs en langage C++
Exercice 1 :
Définir une
classe permettant d’additionner, de soustraire, de multiplier, de diviser et de
donner l’opposé (-) des fractions (rationnels comprenant numérateur et
dénominateur) en utilisant la surcharge de ces opérateurs.
Créer un
programme permettant de tester cette classe.
Solution :
#include <iostream.h>
class operation{
float num;
float deno;
public:
operation(float numerateur=1, float denominateur=1);
friend operation operator+(operation fct1, operation
fct2);
friend operation operator-(operation fct1, operation
fct2);
friend operation operator* (operation fct1, operation
fct2);
friend operation operator/(operation f1, operation
f2);
void affiche();
};
operation::operation (float numerateur, float
denominateur){
num= numerateur;
deno=denominateur;
}
operation operator+ (operation fct1, operation fct2){
//ressemble a constructeur par
copie
operation res;
res.deno= fct1.deno*fct2.deno;
res.num=(fct1.num*fct2.deno)+(fct2.num*fct1.deno);
return res;
}
operation operator- (operation fct1, operation fct2){
//ressemble a constructeur par
copie
operation res;
res.deno= fct1.deno*fct2.deno;
res.num=(fct1.num*fct2.deno)-(fct2.num*fct1.deno);
return res;
}
operation operator* (operation fct1, operation fct2){
//ressemble a constructeur par
copie
operation res;
res.deno= fct1.deno*fct2.deno;
res.num=fct1.num*fct2.num;
return res;
}
operation operator/(operation f1, operation f2) {
operation res;
if(f2.num == 0) {
res.num = 0;
res.deno = 1;
cout <<
"division par 0 pas possible" << endl;
}
else {
res.deno = f1.deno * f2.num;
res.num = f1.num * f2.deno;
}
return res;
}
// opposé ???????
void operation::affiche(){
cout<<num<<" /
"<<deno<<endl;
}
void main(){
operation a(2,3);
operation b(1,2);
operation c;
c=a+b;
c.affiche();
c=a-b;
c.affiche();
c=a*b;
c.affiche();
c=a/b;
c.affiche();
}
Exercice 2 :
Soit la classe
vecteur3d qui contient les coordonnées du vecteur (float), un constructeur
initialisant les données membres avec des valeurs par défaut à 0.
Il faut définir
l’opérateur + pour qu’il fournisse la somme de deux vecteurs et l’opérateur
binaire * pour qu’il fournisse le produit scalaire de deux vecteurs.
Créer un
programme permettant de tester cette classe.
Solution :
#include <iostream.h>
class vecteur3d{
float x;
float y;
float z;
public:
vecteur3d(float
x1=0, float y1=0, float z1=0);
friend vecteur3d
operator+(vecteur3d vect1, vecteur3d vect2);
friend vecteur3d
operator*(vecteur3d vect1, vecteur3d vect2);
void affiche();
};
vecteur3d::vecteur3d(float
x1, float y1, float z1){
x=x1;
y=y1;
z=z1;
}
vecteur3d
operator+(vecteur3d vect1, vecteur3d vect2){
vecteur3d
result;
result.x=vect1.x+vect2.x;
result.y=vect1.y+vect2.y;
result.z=vect1.z+vect2.z;
return result;}
vecteur3d
operator*(vecteur3d vect1, vecteur3d vect2){
vecteur3d
result;
result.x=vect1.x*vect2.x;
result.y=vect1.y*vect2.y;
result.z=vect1.z*vect2.z;
return result;}
void
vecteur3d::affiche(){
cout<<"("<<x<<","<<y<<","<<z<<")";
}
void main(){
vecteur3d
a(2,3,4);
vecteur3d
b(1,2,5);
vecteur3d c;
c=a+b;
c.affiche();
c=a*b;
c.affiche();
}
Exercice 3 :
Créer une classe
permettant d’additionner (surcharge de +), de soustraire(surcharge de -), de
lire et d’afficher des dates simples au format jj/mm (ne pas prendre en compte
les années bissextiles).
Solution:
#include <iostream.h>
class date{
int jj;
int mm;
public:
date(int jour=0,
int mois=0); // pas oublier d'initialiser sinon ca pose probleme
friend date operator-(date d1, date d2);
friend date operator+(date d1,date d2);
void lire();
void affiche();
};
date::date(int
jour, int mois){
jj=jour;
mm=mois;
}
date operator+(date d1, date d2){
date result;
result.jj=d1.jj+d2.jj;
result.mm=d1.mm+d2.mm;
return result;
}
date operator-(date d1, date d2){
date result;
result.jj=d1.jj-d2.jj;
result.mm=d1.mm-d2.mm;
return result;
}
void date::lire(){
cout<<"Entrer
le jour : "<<endl;
cin>>jj;
cout<<"Entrer
la date : "<<endl;
cin>>mm;
}
void
date::affiche(){
cout<<"
le resultat de l'operation sur les dates "<<endl;
cout<<jj<<"
/ "<<mm<<endl;
}
void main(){
date a;
date b;
date c;
a.lire();
b.lire();
c=a+b;
c.affiche();
c=a-b;
c.affiche();
}
Exercice 4 :
Implémenter dans
la classe de l’exercice 3 :
- une surcharge
de >> permettant d’entrer le jour et le mois
- une surcharge
de << permettant d’afficher le jour et le mois (2 chiffres pour
chaque)
- une surcharge
de ++ qui incrémente la date d’un jour
- une surcharge
de - - qui décrémente la date d’un jour
- une surcharge
de == permettant de comparer 2 dates
Solution:
#include <iostream.h>
class date{
int jj;
int mm;
public:
date(int jour=0,
int mois=0); // pas oublier d'initialiser sinon ca pose probleme
friend date operator-(date d1, date d2);
friend date operator+(date d1,date d2);
friend istream& operator>>(istream&
tmp,date& d);
friend ostream& operator<<(ostream&
tmp,date d);
date operator --(int);
date& operator --();
date operator ++(int);
date& operator ++();
void lire();
void affiche();
};
date::date(int
jour, int mois){
jj=jour;
mm=mois;
}
date operator+(date d1, date d2){
date result;
result.jj=d1.jj+d2.jj;
result.mm=d1.mm+d2.mm;
return result;
}
date operator-(date d1, date d2){
date result;
result.jj=d1.jj-d2.jj;
result.mm=d1.mm-d2.mm;
return result;
}
istream& operator>>(istream&
tmp,date& d){
cout<<"Entrez
la date svp"<<endl;
tmp>>d.jj;
tmp>>d.mm;
return tmp;
}
ostream& operator<<(ostream& tmp,date
d){
cout<<endl;
cout<<"Voici
la date"<<endl;
tmp<<d.jj;
cout<<" / ";
tmp<<d.mm;
return tmp;
}
date date
::operator--(int){// attention au placement du ::
date tmp=*this;
tmp.jj--;
tmp.mm--;
return tmp;
}
date& date::operator --(){
jj--;
mm--;
return *this;
}
date date ::operator++(int){// attention au placement
du ::
date tmp=*this;
tmp.jj++;
tmp.mm++;
return tmp;
}
date& date::operator ++(){
jj++;
mm++;
return *this;
}
void date::lire(){
cout<<"Entrer
le jour : "<<endl;
cin>>jj;
cout<<"Entrer
la date : "<<endl;
cin>>mm;
}
void
date::affiche(){
cout<<"
le resultat de l'operation sur les dates "<<endl;
cout<<jj<<"
/ "<<mm<<endl;
}
void main(){
date a;
date b;
date c;
a.lire();
//b.lire();
cin>>b;
c=a+b;
c.affiche();
c=a-b;
cout<<c;
c--;
--c;
c.affiche();
++c; // on
utilisera cette operation
c++;
c.affiche();
}
Exercice 5 :
Implémenter dans
la classe de l’exercice 2 :
- une surcharge
de l’opérateur d’affectation
- une surcharge
de +=
- une surcharge
de ==
- une surcharge
de – qui décrémente les coordonnées du vecteur de 1
- une surcharge
de >> qui permet d’entrer les composantes du vecteur
- une surcharge
de << qui permet d’afficher les composantes du vecteur.
- une surcharge
de l’opérateur d’indexation qui retourne la coordonnée suivant x
ou suivant y ou
suivant z selon l’indice passé en paramètre.
Solution:
#include <iostream.h>
#include <string.h>
class vecteur3d{
/*float taille;
float *adresse;
*/
float x; // en public
pour mon operateur d'indexation
float y;
float z;
float adr[3];
public:
vecteur3d(float
x1=0, float y1=0, float z1=0);
friend
vecteur3d/*valeur de retour */ operator+(vecteur3d vect1, vecteur3d
vect2);
friend
vecteur3d/*valeur de retour */ operator-(vecteur3d vect1, vecteur3d
vect2);
friend vecteur3d
operator*(vecteur3d vect1, vecteur3d vect2);
friend ostream& operator<<(ostream& tmp
, vecteur3d v);
friend istream& operator>>(istream& tmp,
vecteur3d& v);
float& operator[] (int i);
vecteur3d& operator +=(vecteur3d& v);
friend bool operator==(vecteur3d v1,vecteur3d v2);
vecteur3d&
operator=(vecteur3d v);
void affiche();
~vecteur3d();
};
vecteur3d::vecteur3d(float
x1, float y1, float z1){
x=x1;
y=y1;
z=z1;;
adr[0]=x;
adr[1]=y;
adr[2]=z;
}
vecteur3d::~vecteur3d(){
}
float& vecteur3d::operator[] (int i){
return adr[i];
}
vecteur3d operator+(vecteur3d vect1, vecteur3d vect2){
vecteur3d result;
result.x=vect1.x+vect2.x;
result.y=vect1.y+vect2.y;
result.z=vect1.z+vect2.z;
return result;}
vecteur3d
operator-(vecteur3d vect1, vecteur3d vect2){
vecteur3d
result;
result.x=vect1.x-vect2.x;
result.y=vect1.y-vect2.y;
result.z=vect1.z-vect2.z;
return result;}
vecteur3d
operator*(vecteur3d vect1, vecteur3d vect2){
vecteur3d
result;
result.x=vect1.x*vect2.x;
result.y=vect1.y*vect2.y;
result.z=vect1.z*vect2.z;
return result;}
vecteur3d&
vecteur3d::operator +=(vecteur3d& v){
x+=v.x;
y+=v.y;
z+=v.z;
return *this;
}
bool operator==(vecteur3d v1,vecteur3d v2){
if((v1.x==v2.x) && (v1.y==v2.y) &&
(v1.z==v2.z)) return true;
else return false;
}
vecteur3d& vecteur3d::operator=(vecteur3d v){
x=v.x;
y=v.y;
z=v.z;
return *this;
}
ostream& operator<<(ostream& tmp,
vecteur3d v){
tmp<<"X
= "<<v.x<<", Y= "<<v.y<<", Z=
"<<v.z<<endl;
return tmp;
}
istream& operator>>(istream& tmp,
vecteur3d& v){
//pas de
vecteur3d::
cout<<
" Entrer les valeurs de x,y,z"<<endl;
tmp>>v.x;
tmp>>v.y;
tmp>>v.z;
return tmp;
}
void
vecteur3d::affiche(){
cout<<"("<<x<<","<<y<<","<<z<<")";
}
void main(){
//vecteur3d
a(2,3,4);
vecteur3d a;
vecteur3d b;
vecteur3d
d(1,1,1);
vecteur3d c;
/* a.x=a[0];
a.y=a[1];
a.z=a[2];
for (i=0;i<3;i++){
cin>>a[i];
}
for (i=0;i<3;i++){
cout<<a[i]<<endl;
}
*/
cin>>a;
cout<<a;
cin>>b;
if(a==b){
cout<<"Valeurs
identiques"<<endl;
}
else{
cout<<"Valeurs
différentes"<<endl;
}
c=b-d;
//c.affiche();
cout<<c;
c=a+b;
c.affiche();
c=a*b;
c.affiche();
a+=b;
a.affiche();
a=b;
a.affiche();
vecteur3d
k(1,1,2);
for (float i=0;i<3;i++){
cout<<k[i]<<endl;
}
}
Exercice 6 :
Implémenter dans
la classe de l’exercice 1 :
- une surcharge
des opérateurs de pré et post incrémentation
- une surcharge
de l’opérateur de conversion en float
- une surcharge
de l’opérateur d’exponentiation sous la forme
rationnel
operator ^(rationnel&, unsigned &) . Exemple : si x=2/5 alors x^4
retourne le
rationnel 16/625
- une surcharge
de l’opérateur d’exponentiation sous la forme
rationnel
operator ^(rationnel&, int &) . Exemple : si x=2/5 alors x^-4
retourne le
rationnel 625/16
- une surcharge
de l’opérateur << qui permet d’afficher le numérateur et le
dénominateur
Solution:
#include <iostream.h>
#include <math.h>
class operation{
float num;
float deno;
public:
operation(float numerateur=1, float denominateur=1);
friend operation operator+(operation fct1, operation
fct2);
friend operation operator-(operation fct1, operation
fct2);
friend operation operator* (operation fct1, operation
fct2);
friend operation operator/(operation f1, operation
f2);
friend operation operator~(operation f);
operation operator++(int); //post
operation& operator++(); //pré
operator float();
friend operation operator^(operation op,unsigned
&);
friend operation operator^(operation op, int& ex);
void affiche();
};
operation::operation (float numerateur, float
denominateur){
num= numerateur;
deno=denominateur;
}
operation operator+ (operation fct1, operation fct2){
//ressemble a constructeur par
copie
operation res;
res.deno= fct1.deno*fct2.deno;
res.num=(fct1.num*fct2.deno)+(fct2.num*fct1.deno);
return res;
}
operation operator- (operation fct1, operation fct2){
//ressemble a constructeur par
copie
operation res;
res.deno= fct1.deno*fct2.deno;
res.num=(fct1.num*fct2.deno)-(fct2.num*fct1.deno);
return res;
}
operation operator* (operation fct1, operation fct2){
//ressemble a constructeur par
copie
operation res;
res.deno= fct1.deno*fct2.deno;
res.num=fct1.num*fct2.num;
return res;
}
operation operator/(operation f1, operation f2) {
operation res;
if(f2.num == 0) {
res.num = 0;
res.deno = 1;
cout <<
"division par 0 pas possible" << endl;
}
else {
res.deno = f1.deno * f2.num;
res.num = f1.num * f2.deno;
}
return res;
}
operation operator~(operation f){
operation res;
res.num=-f.num;
res.deno=f.deno;
return res;
}
operation& operation::operator ++(){
num++;
deno++;
return *this;
}
operation operation::operator ++(int){
operation tmp=*this;
tmp.num++;
tmp.deno++;
return tmp;
}
operation::operator float(){
float res=num/deno;
return res;
}
operation operator^(operation op, unsigned& ex){
operation tmp;
tmp.num=pow(op.num,ex);
tmp.deno=pow(op.deno,ex);
return tmp;
}
operation operator^(operation op, int& ex){
operation tmp;
tmp.num=pow(op.num,ex);
tmp.deno=pow(op.deno,ex);
return tmp;
}
void operation::affiche(){
cout<<num<<"
/ "<<deno<<endl;
}
// surcharge de
l'opérateur << --> voir les exo précédents
void main(){
operation a(2,3);
operation b(2,5);
operation c;
c=a+b;
c.affiche();
c=a-b;
c.affiche();
c=a*b;
c.affiche();
c=a/b;
c.affiche();
c=~a;
c.affiche();
c=a++;
c.affiche();
a.affiche();
c=++a;
c.affiche();
a.affiche();
float h;
h=float(a);
cout<<"conversion "<<h<<endl;
unsigned int g=4;
c=operator^(b,g);
c.affiche();
int j=(-4);
c=operator^(b,j);
c.affiche();
}
Exercice 7 :
Créer une classe
matrice qui permet de gérer des matrices à 2 dimensions. Elle
comprend les
données membres privées : nombre de ligne, nombre de colonne et une
gestion
dynamique pour stocker les éléments (doubles) de la matrice.
Elle comprend un
constructeur et un destructeur.
Elle comprend la
surcharge de l’opérateur <<, de l’opérateur(), de l’opérateur new et
de l’opérateur
delete .
L’opérateur ()
devra être utilisé pour stocker les éléments dans la matrice.
Créer un
programme permettant de tester la classe matrice.
Solution:
#include <iostream.h>
#include<stddef.h> // utile pour size_t
#include<stdlib.h>
class matrice{
int nbres_lg;
int nbres_cl;
int *tab;
public:
matrice(int nblg,int nbcl);
friend ostream& operator<<( ostream&
tmp,matrice d);
int* operator()(matrice& d);
void * operator new (size_t);
void operator delete(void *p);
void affiche();
};
matrice::matrice(int
nblg,int nbcl){
nbres_lg=nblg;
nbres_cl=nbcl;
tab=new int[nbres_lg*nbres_cl];
for (int i=0;i<nbres_lg*nbres_cl;i++) tab[i]=0;
}
ostream& operator<<(ostream& tmp,
matrice d){
for (int i=0; i<d.nbres_lg;i++){
for(int j=0;j<d.nbres_cl;j++){
tmp<<"tab["<<i<<"]["<<j<<"]="<<d.tab[(2*i*(d.nbres_cl-
1))+j]<<endl;
//voir cours de
Mr Wilfart
//sur
l'allocation des tableaux
}
}
return tmp;
}
int* matrice::operator ()(matrice& d){
for (int l=0;l<d.nbres_lg;l++)
{
for(int c=0;c<d.nbres_cl;c++)
{
cout<<"entrez
la valeur que vous desirez pour la
matrice["<<l<<";"<<c<<"]:"<<endl;
cin>>d.tab[(2*l*(d.nbres_cl-1))+c];
}
}
return d.tab;
}
void * matrice::operator new(size_t sz){
cout<<"appel new"<<endl;
return malloc(sz);}
void matrice::operator delete(void *p){
free(p);
cout<<"appel
delete\n";
}
void
matrice::affiche(){
for (int l=0;l<nbres_lg;l++)
{
for(int c=0;c<nbres_cl;c++)
{
cout<<tab[(2*l*(nbres_cl-1))+c]<<endl;
}
}
}
void main(){
matrice a(2,2);
a(a);
a.affiche();
cout<<a;
matrice *b=new
matrice(a); // en paramètre de ou il va chercher sa reference
// c a d d'une
autre matrice
cout<<a;
delete b;
}
Exercice 8 :
Écrire une
classe vecteur comportant :
- en membres
donnée privés : trois composantes de type double
- un
constructeur qui initialise les valeurs des composantes
- une surcharge
de * permettant de multiplier les composantes par une valeur
- une surcharge
de = = permettant de comparer 2 vecteurs
- une surcharge
des opérateurs >> et <<.
Créer un
programme permettant de tester la classe vecteur.
Solution:
#include <iostream.h>
class vecteur{
double x;
double y;
double z;
public:
vecteur(double
x1=0, double y1=0, double z1=0); //ATTENTION;-)
friend vecteur
operator*(vecteur v1, vecteur v2);
friend bool operator==(vecteur v1, vecteur v2);
friend ostream& operator<<(ostream&
tmp,vecteur v);
friend istream& operator>>(istream&
tmp,vecteur& v);
};
vecteur::vecteur(double
x1, double y1, double z1){
x=x1;
y=y1;
z=z1;
}
vecteur
operator*(vecteur v1, vecteur v2){
vecteur tmp;
tmp.x=v1.x*v2.x;
tmp.y=v1.y*v2.y;
tmp.z=v1.z*v2.y;
return tmp;
}
ostream& operator<<(ostream& tmp,vecteur
v){
tmp<<"X
= "<<v.x<<"Y = "<<v.y<<"Z =
"<<v.z<<endl;
return tmp;
}
istream& operator>>(istream&
tmp,vecteur& v){
cout<<"
Entrez les valeurs de x,y et z"<<endl;
tmp>>v.x;
tmp>>v.y;
tmp>>v.z;
return tmp;
}
bool operator==(vecteur v1, vecteur v2){
if
((v1.x==v2.x)&&(v1.y==v2.y)&&(v1.z==v2.z)) return true;
else return false;
}
void main(){
vecteur
a(2,3,4);
vecteur
b(2.2,3.3,4);
vecteur c;
c=a*b;
vecteur d;
cin>>d;
cout<<d;
if (a==d)
cout<<"valeurs identiques"<<endl;
else
cout<<"valeurs différentes"<<endl;
}
L’héritage en
programmation C++
Exercice 1 :
Créer une classe
personnel comprenant 3 données membres (nom, position, salaire),
un constructeur
initialisant les données membres et une fonction affiche_personnel
qui affiche les
informations sur le personnel.
Créer une classe
patron dérivant publiquement de la classe personnel et ayant 2
données membres
(bonus_annuel, marque de voiture de fonction) , un constructeur
initialisant les
données membres et une fonction affiche_patron qui affiche les
informations sur
le patron (entant que membre du personnel et patron).
Créer un
programme permettant de tester ces classes.
Solution:
#include <iostream.h>
#include <string.h>
class personnel{
char *nom;
char *position;
int salaire;
public:
personnel(char
*nm, char *pos, int sal);
void
affiche_personnel();
};
class
patron:public personnel{/*class sousClasse: droit superClasse{};*/
int
bonus_annuel;
char*
marque_voiture;
public :
//constructeur
//sousClasse(liste
des paramètres (avec ceux de la super classe); //déclaration
//sousClasse::sousClasse(liste
de paramètres) : superClasse(paramètres pour
superClasse){}
//définition
patron(int b_a,
char* m_v,char *nm, char *pos, int sal);
void
affiche_patron();
};
personnel::personnel(char
*nm, char *pos, int sal){
cout<<"constructeur"<<endl;
salaire=sal;
nom=nm;
position=pos;
}
void
personnel::affiche_personnel(){
cout<<"Nom
: "<<nom<<endl;
cout<<"Position
: "<<position<<endl;
cout<<"Salaire
: "<<salaire<<endl;
}
patron::patron(int
b_a, char* m_v,char *nm, char *pos, int sal):personnel(nm, pos,sal)
{
bonus_annuel=b_a;
marque_voiture=m_v;
}
void
patron::affiche_patron(){
affiche_personnel();
//pas oublier
cout<<"bonus
annuel = "<<bonus_annuel<<endl;
cout<<"Marque
de voiture = "<<marque_voiture<<endl;
}
void main(){
personnel
b("gerald","gérant",1250);
patron
a(500,"BMW","fallon","PDG",2000);
b.affiche_personnel();
a.affiche_patron();
}
Exercice 2 :
a) Modifier les
classes définies dans l’exercice 1 en utilisant la fonction affiche dans
la classe de
base et la classe dérivée.
Modifier le
programme pour tester les modifications.
b) Créer dans le
programme principal un pointeur sur la classe personnel et un objet
de la classe
patron. Le pointeur sur la classe de base contient l’adresse de la classe
dérivée. Appeler
la fonction affiche en utilisant le pointeur sur la classe de base (il
faut qu’elle
affiche les informations sur la classe dérivée).
Solution:
#include <iostream.h>
#include <string.h>
class personnel{
char *nom;
char *position;
int salaire;
public:
personnel(char
*nm, char *pos, int sal);
void affiche();
};
class
patron:public personnel{/*class sousClasse: droit superClasse{};*/
int
bonus_annuel;
char*
marque_voiture;
public :
//constructeur
//sousClasse(liste
des paramètres (avec ceux de la super classe); //déclaration
//sousClasse::sousClasse(liste
de paramètres) : superClasse(paramètres pour
superClasse){}
//définition
patron(int b_a,
char* m_v,char *nm, char *pos, int sal);
void affiche();
};
personnel::personnel(char
*nm, char *pos, int sal){
cout<<"constructeur"<<endl;
salaire=sal;
nom=nm;
position=pos;
}
void
personnel::affiche(){
cout<<"Nom
: "<<nom<<endl;
cout<<"Position
: "<<position<<endl;
cout<<"Salaire
: "<<salaire<<endl;
}
patron::patron(int
b_a, char* m_v,char *nm, char *pos, int sal):personnel(nm, pos,sal)
{
bonus_annuel=b_a;
marque_voiture=m_v;
}
void
patron::affiche(){
//cout<<"Nom
: "<<nom<<endl;
//cout<<"Position
: "<<position<<endl;
//cout<<"Salaire
: "<<salaire<<endl;
personnel::affiche();
// si on ne veut
pas utiliser la résolution de portée
//on mets nos
données en mode protected
cout<<"bonus
annuel = "<<bonus_annuel<<endl;
cout<<"Marque
de voiture = "<<marque_voiture<<endl;
}
void main(){
/*
personnel
b("gerald","gérant",1250);
patron a(500,"BMW","fallon","PDG",2000);
b.affiche();
a.affiche();
*/
personnel
*pe=new personnel("Fallon","PDG",2000);
peà affiche();
patron *pa=new
patron(500,"PORSCHE","Toujirat","HautPDG",2250);
paàaffiche();
}
Exercice 3 :
Créer une classe
animal, puis des classes dérivées à poils et à plumes où vous dérivez
les
particularités respectives de chaque animal. Dans la classe de base,
implémentez
sous forme de
méthodes virtuelles les fonctions qui concernent l’animal en général
mais
s’appliquent différemment selon le type d’animal.
Solution:
#include <iostream.h>
#include <string.h>
class animal{
protected:
char nom[20];
public:
animal(char n[20]="");
virtual void manger();
};
class poils:public animal{
int pattes;
public:
poils(int pt=0,char n[20]="");
void manger();
};
class plumes:public animal{
int pattes;
public:
plumes(int pt=0,
char n[20]="");
void manger();
};
animal::animal(char
n[20]){
strcpy(nom,n);
}
void
animal::manger(){
cout<<"
l'animal suivant : "<<nom<<" a besoin de manger pour
survivre"<<endl;
}
poils::poils(int
pt,char n[20]):animal(n){
pattes=pt;
}
void
poils::manger(){
cout<<"l'animal
suivant : "<<nom<<" est carnivore"<<endl;
}
plumes
::plumes(int pt,char n[20]):animal(n){
pattes=pt;
}
void
plumes::manger(){
cout<<"l'animal
suivant :"<<nom<<" n'est pas carnivore et aime les
graines"<<endl;
}
void main(){
animal
p("tortue");
p.manger();
poils
q(4,"chat");
q.manger();
plumes
s(2,"pigeon");
s.manger();
animal *r;
r=&s;
r->manger();
}
Exercice 4 :
Créer une classe
nombre formée d’une unique variable entière et d’une méthode
affiche_nombre,
puis définir 3 classes dérivées afin d’afficher la variable aux formats
hexadécimal,
octal et décimal à l’aide d’une méthode affiche_nombre.
Solution:
#include <iostream.h>
class nombre{
protected:
int entier;
public:
nombre(int ent);
virtual void
affiche_nombre();
};
class
hexa:public nombre{
public:
hexa(int ent);
void
affiche_nombre();
};
class
octal:nombre{
public:
octal(int ent);
void
affiche_nombre();
};
class
decimal:nombre{
public:
decimal(int ent);
void
affiche_nombre();
};
nombre::nombre(int
ent){
entier=ent;
}
void
nombre::affiche_nombre(){
cout<<"voici
le nombre : "<<entier<<endl;
}
hexa::hexa(int
ent):nombre(ent){}
void
hexa::affiche_nombre(){
cout
<<" le nombre en hexa est de : "<<hex<<entier<<endl;
}
octal::octal(int
ent):nombre(ent){}
void
octal::affiche_nombre(){
cout
<<" le nombre en octal est de :
"<<oct<<entier<<endl;
}
decimal::decimal(int
ent):nombre(ent){}
void
decimal::affiche_nombre(){
cout
<<" le nombre en décimal est de : "<<dec<<entier<<endl;
}
void main(){
nombre a(12);
a.affiche_nombre();
decimal b(12);
b.affiche_nombre();
octal c(12);
c.affiche_nombre();
hexa d(12);
d.affiche_nombre();
}
Exercice 5 :
a) Créer une
classe Date ayant 3 paramètres jour, mois, année.
Elle contient un
constructeur initialisant les données membres.
Elle contient les fonctions getDay(), getMonth(),
getYear(), setDay(), setMonth(),
setYear() et
DateToString()
Le constructeur
attend en paramètre l'année, le mois puis le numéro de jour et les affecte dans
l'espace de données privé de l'objet.
Les méthodes
accesseurs permettent respectivement de récupérer le jour, le mois ou l'année
sous forme d'un entier (méthodes getxxx) et de changer ces mêmes propriétés
(méthodes setxxx). La méthode DateToString retourne une chaîne de caractères
représentant la date de l'objet sur lequel a été invoquée cette méthode au
format américain.
b) Nous voyons
que le constructeur et la méthode DateToString travaillent sur le format
américain. Comme cette classe est intégrée dans les librairies d'un
environnement de développement, il n'est pas possible de la modifier. Quelle
technique nous offre la programmation orientée objet pour pouvoir gérer nos
dates au format français tout en utilisant cette classe existante qui offre en
outre un ensemble d'autres services ? Écrire le code correspondant pour gérer
un constructeur et une méthode retournant une chaîne au format français.
Solution:
#include <iostream.h>
#include <string>
#include <stdlib.h>
using namespace std;
class date{
protected:
int jour;
int mois;
int annee;
public:
date(int jr=0, int ms=0, int an=0);
void getday();
void getmonth();
void getyear();
void setday();
void setmonth();
void setyear();
virtual string datetostring();
};
class datefr:public date{
public:
datefr(int jr=0, int ms=0, int an=0);
string datetostring();
};
datefr::datefr(int jr, int ms, int
an):date(jr,ms,an){}
string datefr::datetostring(){
char tab1[60]="";
char
tab2[20]="";
char
tab3[20]="";
cout<<"date
en version europeenne"<<endl;
itoa(jour,tab1,10);
itoa(mois,tab2,10);
itoa(annee,tab3,10);
strcat(tab1,tab2);
//cout<<tab1<<endl;
strcat(tab1,tab3);
//cout<<tab1<<endl;
return tab1;
}
date::date(int
jr, int ms, int an){
jour=jr;
mois=ms;
annee=an;
}
void date::getday(){
cout<<"Jour
:"<<jour;
}
void
date::getmonth(){
cout<<"Mois
:"<<mois;
}
void
date::getyear(){
cout<<"Annee
:"<<annee<<endl;
}
void date::setday(){
cout<<"Entrer
le jour"<<endl;
cin>>jour;
}
void
date::setmonth(){
cout<<"Entrer
le mois"<<endl;
cin>>mois;
}
void date::setyear(){
cout<<"Entrer
l' annee"<<endl;
cin>>annee;
}
string
date::datetostring(){
char
tab1[60]="";
char
tab2[20]="";
char
tab3[20]="";
itoa(annee,tab1,10);
itoa(mois,tab2,10);
itoa(jour,tab3,10);
strcat(tab1,tab2);
//cout<<tab1<<endl;
strcat(tab1,tab3);
//cout<<tab1<<endl;
return tab1;
}
void main(){
date a;
a.setday();
a.setmonth();
a.setyear();
a.getday();
a.getmonth();
a.getyear();
string tab= a.datetostring();
for(int i=0;i<20;i++)
cout<<tab[i];
cout<<endl;
datefr b(22,9,81);
string tab1=b.datetostring();
for(int j=0;j<20;j++)
cout<<tab1[j];
cout<<endl;
}
Exercice 6 :
Créer une classe Etudiant ayant
les mêmes caractéristiques qu'une Personne plus une liste de matières suivies
et un ensemble de notes. On doit pouvoir obtenir la liste des matières,
affecter une note, calculer la moyenne.
Créer une classe Enseignant ayant
les mêmes caractéristiques qu'une Personne plus une liste de matières
enseignées, un nombre d'heures par matière et un tarif horaire. On doit pouvoir
obtenir les matières, faire un calcul du nombre d'heures total et déterminer le
coût de l'enseignant. Les fonctions membres de Etudiant et de Enseignant
doivent pouvoir manipuler
directement les données de la
classe Personne. Modifier en conséquence cette classe.
Créer un tableau d'Etudiant et un
tableau d'Enseignant. Les initialiser. Créer un
tableau de pointeurs de Personne
et affecter selon votre choix à ces personnes soit
un étudiant soit un enseignant.
Afficher l'ensemble des caractéristiques de ces
personnes "polymorphées". Les
détruire.
Solution:
#include <iostream.h>
#include <string.h>
void
menu_etudiant();
void
menu_enseignant();
class personne {
char nom[20];
char prenom[20];
int age;
public:
personne(char n[20]="",char
p[20]="",int a=0) {
strcpy(nom,n);
strcpy(prenom,p);
age=a;
}
void
identification() {
cout<<"Entrez
le nom de la personne : ";
cin>>nom;
cout<<"Entrez
le prenom de la personne : ";
cin>>prenom;
cout<<"Entrez
l'age de la personne : ";
cin>>age;
}
void affiche() {
cout<<"Nom
: "<<nom<<endl;
cout<<"Prenom :
"<<prenom<<endl;
cout<<"Age : "<<age<<endl;
}
};
class
etudiant:personne {
char cours[5];
int *notes;
public:
etudiant(char
n[20],char p[20],int a,char c[5],int *no):personne(n,p,a){
strcpy(cours,c);
notes=new int
[5];
}
void affect_etudiant()
{
personne::identification();
menu_etudiant();
for(int
i=0;i<5;i++) {
cout<<"Quelle
est la matiere ? ";
cin>>cours[i];
if(cours[i]=='x') break;
cout<<"Notes
obtenues ? ";
cin>>notes[i];
}
}
void affiche() {
float moy=0;
personne::affiche();
cout<<"Cours
suivis et notes : "<<endl;
for(int i=0;i<5;i++) {
if(cours[i]=='p')
cout<<"Programmation"<<"
"<<notes[i]<<endl;
if(cours[i]=='e')
cout<<"Electronique"<<"
"<<notes[i]<<endl;
if(cours[i]=='r')
cout<<"Reseau"<<"
"<<notes[i]<<endl;
if(cours[i]=='t')
cout<<"Technologie des composants
electroniques"<<"
"<<notes[i]<<endl;
if(cours[i]=='x') break;
moy=moy+notes[i];
}
cout<<"Moyenne
de l'etudiant : "<<moy/4<<endl;
}
};
class
enseignant:public personne {
char
matieres[5];
int *nbre_heure;
int
tarif_horraire;
public:
enseignant(char
n[20],char p[20],int a,char mat[5],int *heures,int
tarif):personne(n,p,a)
{
strcpy(matieres,mat);
nbre_heure=new
int [5];
tarif_horraire=tarif;
}
void
affect_enseignant() {
personne::identification();
menu_enseignant();
for(int
i=0;i<5;i++) {
cout<<"Une
matiere enseignee : ";
cin>>matieres[i];
if(matieres[i]=='x') break;
cout<<"Nombre
d'heures pour ce cours : ";
cin>>nbre_heure[i];
}
cout<<"Tarif
horraire de cet enseignant : ";
cin>>tarif_horraire;
}
void affiche() {
int
total_heure=0,total_salaire=0;
personne::affiche();
cout<<"Cours
donnes et nombre d'heures : "<<endl;
for(int i=0;i<5;i++) {
if(matieres[i]=='p')
cout<<"Programmation"<<"
"<<nbre_heure[i]<<endl;
if(matieres[i]=='e')
cout<<"Electronique"<<"
"<<nbre_heure[i]<<endl;
if(matieres[i]=='r')
cout<<"Reseau"<<"
"<<nbre_heure[i]<<endl;
if(matieres[i]=='t')
cout<<"Technologie des composants
electroniques"<<"
"<<nbre_heure[i]<<endl;
if(matieres[i]=='m')
cout<<"Laboratoire de micro
controlleur"<<"
"<<nbre_heure[i]<<endl;
if(matieres[i]=='o') cout<<"Micro
ordinateur"<<"
"<<nbre_heure[i]<<endl;
if(matieres[i]=='x') break;
total_heure=total_heure+nbre_heure[i];
}
total_salaire =
total_heure * tarif_horraire;
cout<<"Nombre
d'heures donnees par l'enseignant :
"<<total_heure<<endl;
cout<<"Salaire
de l'enseignant : "<<total_salaire<<endl;
}
};
void main() {
cout<<"Etudiant
: "<<endl;
etudiant
etu1("Touijrat","Abdel",29,"pe",0);
etu1.affect_etudiant();
etu1.etudiant::affiche();
cout<<"Enseignant
: "<<endl;
enseignant
ens1("Dedecker","Jeff",45,"e",0,13);
ens1.affect_enseignant();
ens1.enseignant::affiche();
}
void
menu_etudiant() {
cout<<"Entrez
'p' pour programmation"<<endl;
cout<<"Entrez
'e' pour electronique"<<endl;
cout<<"Entrez
't' pour tce"<<endl;
cout<<"Entrez
'r' pour reseau"<<endl;
cout<<"Pour
arreter, tappez x"<<endl;
}
void
menu_enseignant() {
cout<<"Entrez
'p' pour programmation"<<endl;
cout<<"Entrez
'e' pour electronique"<<endl;
cout<<"Entrez
't' pour tce"<<endl;
cout<<"Entrez
'r' pour reseau"<<endl;
cout<<"Entrez
'm' pour laboratoire de microcontrolleur"<<endl;
cout<<"Entrez
'o' pour micro ordinateur"<<endl;
cout<<"Pour
arreter, tappez x"<<endl;
}
L’héritage
multiple en programmation C++
Exercice 1 :
a) Créer une
classe volante qui a comme donnée membre nombre_ailes et qui a
un constructeur,
un destructeur et une fonction affiche
b) Créer une
classe animal qui a comme données membres nombre_pattes et type_pelage et qui a
un constructeur, un destructeur et une fonction affiche.
c) Créer une
classe oiseau qui dérive publiquement des classes volante et animal.
Elle a comme
donnée membre nombre_oeufs et qui a un constructeur, un destructeur et une
fonction affiche qui affiche la donnée membre et qui fait appel aux fonctions
affiche des classes de base.
d) Créer un
programme qui crée un objet de type oiseau et teste ses fonctions.
Solution:
#include <iostream.h>
#include <string.h>
#define MAX 20
class volante{
int
nombre_ailes;
public:
volante(int
na=2);
~volante();
void affiche();
};
class animal{
int
nombre_pattes;
char
type_pelage[MAX];
public:
animal(int
np=4,char *tp="");
~animal();
void affiche();
};
class
oiseau:public volante,public animal{
int
nombre_oeufs;
public:
oiseau(int
no=1,int na=2,int np=4,char *tp="");
~oiseau();
void affiche();
};
volante::volante(int
na){
nombre_ailes=na;
cout<<"constructeur
volante"<<endl;
}
volante::~volante(){
cout<<"destructeur
volante"<<endl;
}
void
volante::affiche(){
cout<<"nombre
d'ailes:"<<nombre_ailes<<endl;
}
animal::animal(int
np,char *tp){
nombre_pattes=np;
strcpy(type_pelage,tp);
cout<<"constructeur
animal"<<endl;
}
animal::~animal(){
cout<<"destructeur
animal"<<endl;
}
void
animal::affiche(){
cout<<"nombre
de pattes:"<<nombre_pattes<<endl;
cout<<"type
de pelage: "<<type_pelage<<endl;
}
oiseau::oiseau(int
no,int na,int np,char *tp):volante(na),animal(np,tp){
nombre_oeufs=no;
cout<<"constructeur
oiseau"<<endl;
}
oiseau::~oiseau(){
cout<<"destructeur
oiseau"<<endl;
}
void
oiseau::affiche(){
volante::affiche();
animal::affiche();
cout<<"nombre
d'oeufs: "<<nombre_oeufs<<endl;
}
void main()
{
int k;
oiseau o;
o.affiche();
cin>>k;
}
Exercice 2 :
a) Créer une
classe moniteur comprenant :
- les données
membres : type (chaîne de caractères), couleurs (long), x_reso(int) et
y-reso(int)
- un constructeur
initialisant les données membres
- une fonction
montrer_moniteur qui affiche les informations sur le Moniteur
b) Créer une
classe carte_mere comprenant :
- les données
membres : processeur(int), vitesse(int) et ram(int).
- un
constructeur initialisant les données membres.
- une fonction
montrer_carte qui affiche les informations sur la carte.
c) Créer une
classe ordinateur dérivant publiquement des classes moniteur et
carte_mere et
qui contient :
- les données
membres :nom(chaînes de caractères), hd(int),lecteur(float)
- un
constructeur initialisant les données membres
- une fonction
montrer_ordinateur qui affiche les informations sur
l’ordinateur et
appelle les fonctions montrer_moniteur et montrer_carte.
d) Créer un
programme qui crée un objet ordinateur et qui affiche les informations sur
cet
objet
e) Remplacer les
fonctions montrer_moniteur, montrer-carte et montrer_ordinateur par 3 fonctions
appelées montrer.Faire les modifications nécessaires au bon fonctionnement du
programme.
Solution:
//2.a,b,c,d
#include <iostream.h>
#include <string.h>
class moniteur{
char type[5];
long int couleur;
int x_reso;
int y_reso;
public:
moniteur(char tp[5]="", long int coul=0, int
x=0, int y=0);
void montrer_moniteur();
};
class
carte_mere{
int processeur;
int vitesse;
int ram;
public:
carte_mere(int
pro=0, int vi=0, int rm=0);
void
montrer_carte();
};
class
ordinateur:public moniteur, carte_mere{
char nom[10];
int hardisk;
float lecteur;
public:
ordinateur(char
nm[10], int hd, float lct,char tp[5],long int coul, int x, int y,int
pro, int vi, int rm);
//attention ne
pas oublier
void
montrer_ordinateur();
};
moniteur::moniteur(char
tp[5], int long coul, int x, int y){
strcpy(type,tp);
couleur=coul;
x_reso=x;
y_reso=y;
}
void
moniteur::montrer_moniteur(){
cout<<"type
de moniteur: "<<type<<endl;
cout<<"couleur:
"<<couleur<<endl;
cout<<"x_reso:
"<<x_reso<<endl;
cout<<"y_reso:
"<<y_reso<<endl;
}
carte_mere::carte_mere(int pro, int vi, int rm){
processeur=pro;
vitesse=vi;
ram=rm;
}
void carte_mere::montrer_carte(){
cout<<"processeur:
"<<processeur<<endl;
cout<<"vitesse:
"<<vitesse<<endl;
cout<<"ram:
"<<ram<<endl;
}
ordinateur::ordinateur(char
nm[10], int hd, float lct,char tp[5],long int coul, int x, int
y,int pro, int
vi, int rm): moniteur(tp,coul,x,y),carte_mere(pro,vi,rm){
//je mets public
a chak fois... erreur de syntaxe
strcpy(nom,nm);
hardisk=hd;
lecteur=lct;
}
void
ordinateur::montrer_ordinateur(){
moniteur::montrer_moniteur();
carte_mere::montrer_carte();
cout<<"nom
du PC: "<<nom<<endl;
cout<<"hd:
"<<hardisk<<endl;
cout<<"lecteur:
"<<lecteur<<endl;
}
void main()
{
int k;
moniteur
a("moniteur",256,800,600);
a.montrer_moniteur();
cout<<endl;
carte_mere
b(64,3,1024);
b.montrer_carte();
cout<<endl;
ordinateur
c("junior",160,5.4,"moniteur",256,800,600,64,3,1024);
c.montrer_ordinateur();
cin>>k;
}
//2.e
#include <iostream.h>
#include <string.h>
class moniteur{
char type[5];
long int couleur;
int x_reso;
int y_reso;
public:
moniteur(char tp[5]="", long int coul=0, int
x=0, int y=0);
void montrer();
};
class
carte_mere{
int processeur;
int vitesse;
int ram;
public:
carte_mere(int
pro=0, int vi=0, int rm=0);
void montrer();
};
class
ordinateur:public moniteur, carte_mere{
char nom[10];
int hardisk;
float lecteur;
public:
ordinateur(char
nm[10], int hd, float lct,char tp[5],long int coul, int x, int y,int
pro, int vi, int
rm);
//attention ne
pas oublier
void montrer();
};
moniteur::moniteur(char
tp[5], int long coul, int x, int y){
strcpy(type,tp);
couleur=coul;
x_reso=x;
y_reso=y;
}
void
moniteur::montrer(){
cout<<"type
de moniteur: "<<type<<endl;
cout<<"couleur:
"<<couleur<<endl;
cout<<"x_reso:
"<<x_reso<<endl;
cout<<"y_reso:
"<<y_reso<<endl;
}
carte_mere::carte_mere(int pro, int vi, int rm){
processeur=pro;
vitesse=vi;
ram=rm;
}
void carte_mere::montrer(){
cout<<"processeur:
"<<processeur<<endl;
cout<<"vitesse:
"<<vitesse<<endl;
cout<<"ram:
"<<ram<<endl;
}
ordinateur::ordinateur(char
nm[10], int hd, float lct,char tp[5],long int coul, int x, int
y,int pro, int
vi, int rm): moniteur(tp,coul,x,y),carte_mere(pro,vi,rm){
//je mets public
a chak fois... erreur de syntaxe
strcpy(nom,nm);
hardisk=hd;
lecteur=lct;
}
void
ordinateur::montrer(){
moniteur::montrer();
carte_mere::montrer();
cout<<"nom
du PC: "<<nom<<endl;
cout<<"hd:
"<<hardisk<<endl;
cout<<"lecteur:
"<<lecteur<<endl;
}
void main()
{
moniteur
a("moniteur",256,800,600);
a.montrer();
cout<<endl;
carte_mere
b(64,3,1024);
b.montrer();
cout<<endl;
ordinateur c("junior",160,5.4,"moniteur",256,800,600,64,3,1024);
c.montrer();
}
Exercice 3 :
Créer une classe
poste_de_travail dérivant publiquement de la classe ordinateur
(voir exercice 2) Elle contient :
- la donnée
membre syst_exploi (chaîne de caractères)
- un
constructeur initialisant la donnée membre
- une fonction
montrer qui affiche les informations sur le poste de travail en faisant appel à
la
fonction montrer de la classe ordinateur.
Solution:
#include <iostream.h>
#include <string.h>
class moniteur{
char type[5];
long int couleur;
int x_reso;
int y_reso;
public:
moniteur(char tp[5]="", long int coul=0, int
x=0, int y=0);
void montrer();
};
class
carte_mere{
int processeur;
int vitesse;
int ram;
public:
carte_mere(int
pro=0, int vi=0, int rm=0);
void montrer();
};
class
ordinateur:public moniteur, carte_mere{
char nom[10];
int hardisk;
float lecteur;
public:
ordinateur(char
nm[10], int hd, float lct,char tp[5],long int coul, int x, int y,int
pro, int vi, int
rm);
//attention ne
pas oublier
void montrer();
};
class
poste_travail:public ordinateur{
char
syst_exploi[10];
public:
poste_travail(char s_e[10],char nm[10], int hd, float
lct,char tp[5],long int coul, int x,
int y,int pro,
int vi, int rm);
void montrer();
};
poste_travail::poste_travail(char
s_e[10],char nm[10], int hd, float lct,char tp[5],long
int coul, int x,
int y,int pro, int vi, int rm):ordinateur(nm,hd,lct,tp,coul,x,y,pro,vi,rm){
strcpy(syst_exploi,s_e);
}
void
poste_travail::montrer(){
ordinateur::montrer();
cout<<"Systeme
d'exploitation : "<<syst_exploi<<endl;
}
moniteur::moniteur(char
tp[5], int long coul, int x, int y){
strcpy(type,tp);
couleur=coul;
x_reso=x;
y_reso=y;
}
void
moniteur::montrer(){
cout<<"type
de moniteur: "<<type<<endl;
cout<<"couleur:
"<<couleur<<endl;
cout<<"x_reso:
"<<x_reso<<endl;
cout<<"y_reso:
"<<y_reso<<endl;
}
carte_mere::carte_mere(int pro, int vi, int rm){
processeur=pro;
vitesse=vi;
ram=rm;
}
void carte_mere::montrer(){
cout<<"processeur:
"<<processeur<<endl;
cout<<"vitesse:
"<<vitesse<<endl;
cout<<"ram:
"<<ram<<endl;
}
ordinateur::ordinateur(char
nm[10], int hd, float lct,char tp[5],long int coul, int x, int
y,int pro, int
vi, int rm): moniteur(tp,coul,x,y),carte_mere(pro,vi,rm){
//je mets public
a chak fois... erreur de syntaxe
strcpy(nom,nm);
hardisk=hd;
lecteur=lct;
}
void
ordinateur::montrer(){
moniteur::montrer();
carte_mere::montrer();
cout<<"nom
du PC: "<<nom<<endl;
cout<<"hd:
"<<hardisk<<endl;
cout<<"lecteur:
"<<lecteur<<endl;
}
void main()
{
moniteur
a("moniteur",256,800,600);
a.montrer();
cout<<endl;
carte_mere
b(64,3,1024);
b.montrer();
cout<<endl;
ordinateur
c("junior",160,5.4,"moniteur",256,800,600,64,3,1024);
c.montrer();
cout<<endl;
poste_travail d("XP","junior",160,5.4,"moniteur",256,800,600,64,3,1024);
d.montrer();
}
Exercice 4 :
a) Créer une
classe objetassure comprenant :
- les données
membres : montant(float), type (chaîne de caractères)
- un
constructeur initialisant les données membres
- une fonction
affiche qui affiche les informations sur l’objetassure
b) Créer une
classe ordinateur dérivant publiquement de la classe objetassure et comprenant
:
- les données
membres : ram (int), hd(int), …
- un
constructeur initialisant les données membres
- une fonction
affiche qui affiche les informations sur l’ordinateur et qui appelle la
fonction
affiche de la classe objetassure
c) Créer une
classe bagage dérivant publiquement de la classe objetassuré et comprenant :
- les données
membres : type (chaîne de caractères), poids (float)
- un
constructeur initialisant les données membres
- une fonction
affiche affichant les informations sur le bagage et
appelant la
fonction affiche de la classe objetassure.
d) Créer une
classe ordinateurportable dérivant publiquement des classes ordinateur et
bagage
et comprenant :
- les données
membres poids (float) et epaisseur (float)
- un
constructeur initialisant les données membres
- une fonction
affiche qui affiche les informations sur l’ordinateur portable et qui appelle
les fonctions affiche des classes bagage et ordinateur
e) Créer un
programme qui crée un objet ordinateurportable et qui affiche les informations
sur
cet objet
Remarque :
l’ordinateur portable doit bénéficier des 2 assurances, l’une contre le
vol (en tant
qu’ordinateur) et l’autre contre la perte (en tant que bagage).
Solution:
#include <iostream.h>
#include <string.h>
#define MAX 20
class objetassure{
float montant;
char type[MAX];
public:
objetassure(float mt=0.0,char tp[MAX]="");
void affiche();
};
class ordinateur:public virtual objetassure{
int ram;
int hardisk;
public:
ordinateur(int rm=0,int hd=0,float mt=0.0,char
tp[MAX]="");
void affiche();
};
class bagage:virtual public objetassure{
char type1[MAX];
float poids;
public:
bagage(char tp1[MAX]="",float pd=0,float
mt=0.0,char tp[MAX]="");
void affiche();
};
class ordinateurportable:public ordinateur,public
bagage{
float poids1;
float epaisseur;
public:
ordinateurportable(float pd1=0.0,float epaiss=0.0,int
rm=0,int hd=0,char
tp1[MAX]="",float
pd=0.0);
//pas obligation
de mettre les autres paramètres de objetassure
//ici je ne le
fais pas mais pour afficher il vaudrait mieux ;-)
void affiche();
};
objetassure::objetassure(float
mt,char tp[MAX]){
montant=mt;
strcpy(type,tp);
}
void
objetassure::affiche(){
cout<<"montant:
"<<montant<<endl;
cout<<"objet
assure type: "<<type<<endl;
}
ordinateur::ordinateur(int
rm,int hd,float mt,char tp[MAX]):objetassure(mt,tp){
ram=rm;
hardisk=hd;
}
void
ordinateur::affiche(){
objetassure::affiche();
cout<<"Mémoire
type ram : "<<ram<<endl;
cout<<"Disque
Dur: "<<hardisk<<endl;
}
bagage::bagage(char tp1[MAX],float pd,float mt,char
tp[MAX]):objetassure(mt,tp){
strcpy(type1,tp1);
poids=pd;
}
void
bagage::affiche(){
objetassure::affiche();
cout<<"Type
de bagage: "<<type1<<endl;
cout<<"Poids
du bagage: "<<poids<<endl;
}
ordinateurportable::ordinateurportable(float pd1,float
epaiss,int rm,int hd,char
tp1[MAX],float pd):ordinateur(rm,hd),bagage(tp1,pd){
poids1=pd1;
epaisseur=epaiss;
}
void
ordinateurportable::affiche(){
ordinateur::affiche();
bagage::affiche();
cout<<"ordinateur
portable poids: "<<poids1<<endl;
cout<<"epaisseur:
"<<epaisseur<<endl;
}
void main(){
int k;
ordinateurportable
orpor(10,10,256,160,"a main",50);//attention a l affichage
orpor.affiche();
cin>>k;
}
Les fonctions
amies en programmation C++
Exercice 1 :
Soit une classe
vecteur3d ayant 3 données membres privées, de type entier, les composantes du
vecteur (x,y,z). Elle a un constructeur permettant d’initialiser les données
membres.
Ecrire une
fonction indépendante, coincide, amie de la classe vecteur3d, permettant de
savoir si 2
vecteurs ont mêmes composantes.
Si v1 et v2
désignent 2 vecteurs de type vecteur3d, écrire le programme qui permet de
tester l’égalité
de ces 2 vecteurs.
Solution:
#include <iostream.h>
class vecteur3d{
int x;
int y;
int z;
public:
vecteur3d(int
a=0,int b=0, int c=0);
friend void
coincide (vecteur3d p, vecteur3d q);
};
vecteur3d::vecteur3d(int
a,int b,int c){
x=a;
y=b;
z=c;
}
void coincide(vecteur3d
p, vecteur3d q){
if(p.x==q.x
&& p.y==q.y && p.z==q.z){
cout<<"Les
2 vecteurs sont égaux"<<endl;
}
else
cout<<"FOIREUX"<<endl;
}
void main(){
vecteur3d
v1(3,2,5);
vecteur3d
v2(3,4,5);
coincide(v1,v2);
}
Exercice 2 :
Créer 2 classe (dont les membres
données sont privés) :
- l’une nommée vect, permettant
de représenter des vecteurs à 3 composantes de type double ;
elle comportera un constructeur et une
fonction membre affiche.
- L’autre nommée matrice,
permettant de représenter des matrices carrées de dimension 3x3 ;
elle comportera un constructeur avec un
argument (adresse d’un tableau de 3x3 valeurs)
qui initialisera la matrice avec les
valeurs correspondantes.
Réaliser une fonction
indépendante prod permettant de fournir le vecteur correspondant au produit
d’une matrice par un vecteur.
Ecrire un programme de test.
Fournir les 2 déclarations de
chacune des classes, leurs définitions, la définition de prod et le programme
de test.
Solution:
#include <iostream.h>
#include <string.h>
class matrice;
class vect{
double x;
double y;
double z;
public:
vect(double
a=0,double b=0,double c=0);
void affiche();
friend vect prod(matrice b, vect a);
};
class matrice{
double tableau[3][3];
public :
//friend class a;
matrice(double tab[3][3]=0);
friend vect prod(matrice b, vect a);
};
vect::vect(double a,double b, double c){
x=a;
y=b;
z=c;
}
void
vect::affiche(){
cout<<"X=
"<<x<<endl;
cout<<"Y=
"<<y<<endl;
cout<<"Z=
"<<z<<endl;
}
matrice::matrice(double
tab[3][3]){
tableau[3][3]=tab[3][3];
tableau[0][0]=1;
tableau[0][1]=2;
tableau[0][2]=3;
tableau[1][0]=4;
tableau[1][1]=5;
tableau[2][1]=6;
tableau[0][2]=7;
tableau[1][2]=8;
tableau[2][2]=9;
}
vect
prod(matrice b, vect a){
vect c;
c.x=(b.tableau[0][0]*a.x)+(b.tableau[0][1]*a.y)+(b.tableau[0][2]*a.z);
c.y=(b.tableau[1][0]*a.x)+(b.tableau[1][1]*a.y)+(b.tableau[1][2]*a.z);
c.z=(b.tableau[2][0]*a.x)+(b.tableau[2][1]*a.y)+(b.tableau[2][2]*a.z);
cout<<"le
résultat de la multiplication est
:"<<c.x<<","<<c.y<<","<<c.z<<endl;
return c;
}
void main(){
vect
vecteur(1,1,1);
matrice mat;
vect res;
res=prod(mat,vecteur);
}
Subscribe to:
Posts (Atom)