Datasets:
Kant1
/
French_Wikibooks_articles

Dataset card Data Studio Files
xet
Community
1
text
stringlengths
0
211k
Fraction Fraction::operator+(const Fraction & f) const
Fraction r;
r.num = f.den*num + den*f.num;
r.den = f.den*den;
r.normalise();
return r;
Fraction Fraction::operator-(const Fraction & f) const
Fraction r;
r.num = f.den*num - den*f.num;
r.den = f.den*den;
r.normalise();
return r;
Fraction Fraction::operator*(const Fraction & f) const
Fraction r;
r.num = f.num*num;
r.den = f.den*den;
r.normalise();
return r;
Fraction Fraction::operator/(const Fraction & f) const
Fraction r;
r.num = f.den*num;
r.den = f.num*den;
r.normalise();
return r;
using namespace std;
int main()
Fraction f1, f2, f3, f4, E;
cout « "SAISIE de f1 " « endl; cin » f1;
cout « "SAISIE de f2 " « endl; cin » f2;
f3 = Fraction(3, 4);
f4 = Fraction(5, 8);
E = (f1 + f3 - f2) / (f1*f2 - f4) + 4;
cout « "E = " « E « endl;
return 0;
Héritage.
Présentation.
Dans la conception orientée objet, la généralisation consiste à modéliser des concepts communs à un ensemble d'autres concepts. Les autres concepts deviennent dès lors des spécialisations de la généralisation. Cette manière de modéliser s'appelle l'héritage, car les spécialisations héritent de la généralisation. En C++, les classes peuvent hériter d'autres classes et la relation d'héritage est exprimée à l'aide de l'opérateur de dérivation ":".
À partir d'une classe A, on peut créer une classe B qui possède toutes les caractéristiques de la classe A, à laquelle on ajoute un certain nombre de méthodes qui sont spécifiques à B. Cette notion orientée objet fondamentale s'appelle l'héritage.
On dit que :
On dit aussi que:
Il existe en fait trois types d'héritage "public", "private" ou "protected" qui permet de spécifier si oui ou non une méthode de la classe B peut modifier une donnée membre de la classe A, selon qu'elle soit "public", "private" ou "protected".
Syntaxe.
class B : "type_héritage" A
"..."
"type_héritage" est l'un des mots clés d'accès codice_1, codice_3 ou codice_2.
Les membres de A sont alors à la fois accessibles à la classe dérivée B et en dehors de ces classes selon la valeur utilisée pour "type_héritage" :
Pour résumer, "type_héritage" ne peut que restreindre l'accès des membres de la classe A, ou le conserver.
Exemple.
class VehiculeRoulant
public:
VehiculeRoulant();
void avancer();
void accelerer();
protected:
int position, vitesse;
// Initialement à l'arrêt
VehiculeRoulant::VehiculeRoulant()
: position(0)
, vitesse(0)
void VehiculeRoulant::avancer()
position += vitesse;
void VehiculeRoulant::accelerer()
vitesse++;
class Automobile : public VehiculeRoulant
public:
Automobile(int places);
protected:
int m_places;
Automobile::Automobile(int places)
: VehiculeRoulant() // <--- pour initialiser les variables héritées
// position et vitesse
, m_places(places) // initialiser le nombre de places
L'appel explicite au constructeur de la classe de base dans cet exemple n'est pas nécessaire car par défaut, le constructeur (sans paramètres) est appelé.
Dans le cas où il est nécessaire d'appeler un autre constructeur, il faut le faire dans la liste d'initialisation du constructeur de la classe dérivée.
Méthodes virtuelles.
Dans l'exemple précédent, si l'on ajoute une autre méthode à la classe codice_28 :
class VehiculeRoulant
public:
void accelererEtAvancer();
};
void VehiculeRoulant::accelererEtAvancer()
accelerer();
avancer();
et que l'on modifie la façon d'avancer d'une automobile :
class Automobile : public VehiculeRoulant
public:
void avancer();
};
void Automobile::avancer()
position += vitesse - frottementRoues;
Alors si on utilise la méthode codice_29 sur un objet de classe codice_30, le résultat sera incorrect, car la méthode codice_31 appelée sera celle définie par la classe codice_28.
Pour que ce soit celle de la classe codice_30 qui soit appelée, il faut que la méthode codice_31 soit définie comme virtuelle dans la classe de base codice_28 :
class VehiculeRoulant
public:
virtual void avancer();
};
virtual void VehiculeRoulant::avancer()
position += vitesse;
Le mot clé codice_36 indique une méthode virtuelle, c'est-à-dire que son adresse n'est pas fixe, mais dépend de la classe de l'objet (le compilateur construit une table interne des méthodes virtuelles pour chaque classe).
Il est possible d'accéder à une méthode précise de la table des méthodes virtuelles, en indiquant la classe de la méthode à appeler. Par exemple, pour appeler la méthode codice_31 de codice_28 à partir d'une méthode de automobile: