GPA777 (Codage C++) 2

Transcription

1 Exemple de codage C++ Classe Rationnel Rôle Cette classe modélise les nombres rationnels. Raison - Le domaine du problème est simple à comprendre. - Présenter les techniques de programmation C++: Déclaration d une classe Définition d une classe Surcharge des opérateurs Utilisation de la classe - La conception est fort simple. - Montrer les subtilités de la programmation C++: Établissement des constructeurs Conversion implicite de type Conversion explicite de type GPA777 (Codage C++) 1 Nombre rationnel Il est composé d un numérateur (n) et d un dénominateur (d) avec n, d ℵ et d 0. Les calculs par nombres rationnels sont d une grande précision par rapport à la représentation en point flottant. Notre implantation Les opérateurs binaires +, -, * et /. Les opérateurs +=, -=, *= et /= (Pour faciliter leur utilisation dans un programme C++) L opérateur d assignation = Rationnel rat1, rat2; : : : rat1 = 12345; rat2 = rat1; Les opérateurs relationnels ==, <, >,, Les opérateurs unaires + et -. GPA777 (Codage C++) 2 1

2 Notre implantation Les fonctions membres pour retourner le numérateur, le dénominateur du nombre rationnel. Les opérateurs pré (et post) incrémentation (et décrémentation) ++, --. Rationnel rat; : : : rat++; ++rat; --rat; rat-- Les opérateurs de conversion de type. (invoqués implicitement par le compilateur ou explicitement par le programmeur) Les opérateurs non-linéaires: (valeur absolue), é ù (ceil), ë û (floor). (Ces opérateurs retournent un nombre en point flottant sauf ) L opérateur d insertion de flux de sortie <<. (Pour afficher le contenu d un nombre rationnel à la sortie standard) GPA777 (Codage C++) 3 Scénarios d utilisation Déterminer l utilisation de la classe afin d établir les constructeurs nécessaires. Utilisation standard: Rationnel rat; (Régler le dénominateur à 1 pour éliminer la possibilité de division par 0) Création à partir d un numérateur (et d un dénominateur): Rationnel rat(17, 13); Rationnel rat(17); (Régler le dénominateur à 1 pour éliminer la possibilité de division par 0) Création à partir d un autre objet de type Rationnel: Rationnel rat1(17, 13); Rationnel rat2(rat1); GPA777 (Codage C++) 4 2

3 Déclaration de la classe La déclaration sert à indiquer le contenu des classes. Elle sert aussi à déclarer les constantes, les variables et les fonctions (prototypes) à exporter. La déclaration d une classe s effectue dans un fichier.h ou dans un fichier.cpp Fichier.h est appelé fichier d en-tête (header file) Fichier.cpp est le fichier source (corps) et sert à définir une classe Lorsque la classe est simple à créer ou à utiliser, on peut la déclarer dans un fichier.cpp en même temps que sa définition. Pour l implantation de notre classe Rationnel, nous déclarerons son contenu dans un fichier nommé Rationnel.h GPA777 (Codage C++) 5 Déclaration de la classe (Ce projet de programmation est disponible sur la page Web du cours) #if!defined(_rationnel_h) #define _RATIONNEL_H // Wrapper de protection class Rationnel public: // 1) Constructeur par défaut Rationnel() : num(0), den(1) // 2) Constructeur acceptant le numérateur et le dénominateur // n = numérateur, d = dénominateur Rationnel(long n, long d = 1); // 3) Constructeur acceptant un nombre rationnel (rhs = right // hand side) Rationnel(const Rationnel& rhs) : num(rhs.num), den(rhs.den) /* Destructeur: Il ne peut y avoir qu'un seul destructeur par classe. ~Rationnel() GPA777 (Codage C++) 6 3

4 /* Opérateurs d'assignation: Parce que l'on veut pouvoir écrire des assignations de la forme x = y où x est un objet de type Rationnel et y une valeur ou un autre objet de type Rationnel. Rationnel& operator=(const Rationnel& rhs) num = rhs.num; den = rhs.den; return (*this); Rationnel& operator=(long rhs) num = rhs; den = 1; return (*this); /* Fonctions d'accès aux données: Pour obtenir des données de cette classe. Note: Le modificateur "const" indique au compilateur que la fonction ne modifie pas les attributs de l'objet (fonction à lecture seulement). long numerateur(void) const return num; long denominateur(void) const return den; GPA777 (Codage C++) 7 /* Opérateurs unaires: Pour réaliser les opérations telles +x, -x, etc. où x est un objet de la classe Rationnel. Rationnel operator+(void) const // Rappelez-vous -x = (-numérateur)/denominateur lorsque // x est un nombre rationnel. Rationnel operator-(void) const return Rationnel(-num, den); // x = numérateur / denominateur, // inverse(x) = denominateur/numérateur Rationnel inverse(void) const return Rationnel(den, num); /* Opérateurs binaires: Pour réaliser les opérations telles x += y, x-= y où x est un objet de type Rationnel, y est un nombre ou un objet de type Rationnel. const Rationnel& operator+=(const Rationnel& rhs); // addition const Rationnel& operator-=(const Rationnel& rhs); // soustraction const Rationnel& operator*=(const Rationnel& rhs); // multiplication const Rationnel& operator/=(const Rationnel& rhs); // division const Rationnel& operator+=(long rhs); // addition const Rationnel& operator-=(long rhs); // soustraction const Rationnel& operator*=(long rhs); // multiplication const Rationnel& operator/=(long rhs); // division GPA777 (Codage C++) 8 4

5 /* Opérateurs incrémental et décrémental: Pour réaliser les opérations telles ++x, --x (pré), x++, x-- (post) où x est un objet de type Rationnel. const Rationnel& operator++(); // pré const Rationnel operator++(int); // post const Rationnel& operator--(); // pré const Rationnel operator--(int); // post /* Opérateurs de conversion: L'idée est de permet le "typecasting" style C (ex: double(x) où x est un objet de type Rationnel. Aussi, pour les conversions implicites réalisées par le compilateur: d = x + y, où d est un type double (par exemple), x et y du type Rationnel. operator double(void) const return double(num)/den; private: /* Attributs et opérations privés de la classe long num; // numérateur long den; // dénominateur long gcd(long, long);// fonction (plus grand diviseur commun) ; // Fin de la classe Rationnel GPA777 (Codage C++) 9 Dans le même fichier en-tête, nous déclarons également les fonctions utilitaires suivantes: /* /* Fonctions utilitaires et autres qui sont utiles pour nous /* // Conversion explicite Rationnel -> double. Le mot clé inline // veut dire, copier la fonction directement au point d'utilisation. // Donc, plus rapide qu'un appel de fonction. inline double versdouble(const Rationnel& r) return double(r.numerateur())/r.denominateur(); // conversion explicite double -> Rationnel Rationnel versrationnel(double x, int iterations = 5); // Opérateurs mathématiques élémentaires: Pour réaliser la troncature, //l'arrondissement, etc. inline long trunc(const Rationnel& r) return r.numerateur() / r.denominateur(); GPA777 (Codage C++) 10 5

6 inline long floor(const Rationnel& r) long q = r.numerateur() / r.denominateur(); return (r.numerateur() < 0 && r.denominateur()!= 1)? --q : q; inline long ceil(const Rationnel& r) long q = r.numerateur() / r.denominateur(); return (r.numerateur() >= 0 && r.denominateur()!= 1)? ++q : q; // Opérateurs binaires: Pour réaliser les opérations telles // x + y, x - y où x, y est un objet de type Rationnel, y est un // nombre ou un objet de type Rationnel. const Rationnel operator+(const Rationnel& gauche, const Rationnel& droite); const Rationnel operator-(const Rationnel& gauche, const Rationnel& droite); const Rationnel operator*(const Rationnel& gauche, const Rationnel& droite); const Rationnel operator/(const Rationnel& gauche, const Rationnel& droite); // Opérateurs relationnels: Pour réaliser les opérations de comparaison // telles x < y, x > y, etc. bool operator==(const Rationnel& gauche, Rationnel& droite); bool operator!=(const Rationnel& gauche, Rationnel& droite); bool operator<=(const Rationnel& gauche, Rationnel& droite); bool operator>=(const Rationnel& gauche, Rationnel& droite); bool operator<(const Rationnel& gauche, Rationnel& droite); bool operator>(const Rationnel& gauche, Rationnel& droite); GPA777 (Codage C++) 11 // Opérateur d'insertion pour flux de sortie: Pour réaliser l'opération // cout << x où cout est le flux de sortie standard et x est un objet // de type Rationnel. ostream& operator<<(ostream& s, const Rationnel& r); // Valeur absolue d'un nombre rationnel Rationnel rabs(const Rationnel& rat); #endif // Fin du wrapper Nous avons implanté les opérateurs +, -, * et / par des fonctions exportées au lieu des fonctions membres de la classe. On peut ainsi profiter de l existence des opérateurs +=, -=, *= et /= déjà définis dans la classe Rationnel. GPA777 (Codage C++) 12 6

7 Définition de la classe La définition est l implantation des opérations d une classe. Elle sert aussi à donner l implantation des fonctions à exporter. La définition d une classe s effectue dans un fichier.cpp en utilisant les instructions légales de C et de C++. Pour permettre au compilateur de vérifier les types (type checking) utilisés dans notre programme, il est nécessaire d inclure le fichier d en-tête Rationnel.h dans le fichier Rationnel.cpp Il faut également inclure les en-têtes appropriés pour les classes et fonctions utilisées qui ne sont pas du même module. GPA777 (Codage C++) 13 Définition de la classe (Ce projet de programmation est disponible sur la page Web du cours) #include "stdafx.h" #include <stdlib.h> #include <math.h> #include <iostream.h> #include <limits> #include "Rationnel.h" // Pour la précompilation des en-têtes VC++ // exit(), etc. // pour les fonctions mathématiques // pour les flux d'entrée/sortie // grandeurs limites des nombres (Standard C++ lib) // en-tête de notre classe using namespace std; // Espace de nom pour le standard C++ Library Rationnel::Rationnel(long n, long d) if (d == 0L) cerr << "Dénominateur nul" << endl; exit(1); // Le signe est toujours placé sur le numérateur // Ça simplifie le traitement if (d < 0L) n = -n; d = -d; if (n == 0L) num = 0L; den = 1L; GPA777 (Codage C++) 14 7

8 else // Les nombres rationnels sont gardés sous forme // normalisée. long g = gcd(n, d); num = n/g; den = d/g; // fin du constructeur Rationnel() long Rationnel::gcd(long u, long v) long tmp, a = labs(u), b = labs(v); if (b > a) tmp = a; a = b; b = tmp; for (; ;) if (b == 0L) return a; else if (b == 1L) return b; else tmp = b; b = a % b; a = tmp; // fin de gcd() GPA777 (Codage C++) 15 const Rationnel& Rationnel::operator+=(const Rationnel& rhs) long g1 = gcd(den, rhs.den); if (g1 == 1L) num = num * rhs.den + den * rhs.num; den = den * rhs.den; else long t = num * (rhs.den/g1) + (den/g1) * rhs.num; long g2 = gcd(t, g1); num = t/g2; den = (den/g1) * (rhs.den/g2); // fin de operator+= const Rationnel& Rationnel::operator+=(long rhs) num = num + den * rhs; // fin de operator+= const Rationnel operator+(const Rationnel& gauche, const Rationnel& droite) return Rationnel(gauche) += droite; // fin de operator+ Fonction utilitaire (non membre) GPA777 (Codage C++) 16 8

9 const Rationnel& Rationnel::operator-=(const Rationnel& rhs) long g1 = gcd(den, rhs.den); if (g1 == 1L) num = num * rhs.den - den * rhs.num; den = den * rhs.den; else long t = num * (rhs.den/g1) - (den/g1) * rhs.num; long g2 = gcd(t, g1); num = t/g2; den = (den/g1) * (rhs.den/g2); // fin de operator-= const Rationnel& Rationnel::operator-=(long rhs) num = num - den * rhs; // fin de operator-= const Rationnel operator-(const Rationnel& gauche, const Rationnel& droite) return Rationnel(gauche) -= droite; // fin de operator- Fonction utilitaire (non membre) GPA777 (Codage C++) 17 const Rationnel& Rationnel::operator-=(const Rationnel& rhs) long g1 = gcd(den, rhs.den); if (g1 == 1L) num = num * rhs.den - den * rhs.num; den = den * rhs.den; else long t = num * (rhs.den/g1) - (den/g1) * rhs.num; long g2 = gcd(t, g1); num = t/g2; den = (den/g1) * (rhs.den/g2); // fin de operator-= const Rationnel& Rationnel::operator-=(long rhs) num = num - den * rhs; // fin de operator-= const Rationnel operator-(const Rationnel& gauche, const Rationnel& droite) return Rationnel(gauche) -= droite; // fin de operator- Fonction utilitaire (non membre) GPA777 (Codage C++) 18 9

10 const Rationnel& Rationnel::operator*=(const Rationnel& rhs) long g1 = gcd(num, rhs.den); long g2 = gcd(den, rhs.num); num = (num/g1) * (rhs.num/g2); den = (den/g2) * (rhs.den/g1); // fin de operator*= const Rationnel& Rationnel::operator*=(long rhs) long g = gcd(den, rhs); num *= rhs/g; den /= g; // fin de operator*= const Rationnel operator*(const Rationnel& gauche, const Rationnel& droite) return Rationnel(gauche) *= droite; // fin de operator* Fonction utilitaire (non membre) GPA777 (Codage C++) 19 const Rationnel& Rationnel::operator*=(const Rationnel& rhs) long g1 = gcd(num, rhs.den); long g2 = gcd(den, rhs.num); num = (num/g1) * (rhs.num/g2); den = (den/g2) * (rhs.den/g1); // fin de operator*= const Rationnel& Rationnel::operator*=(long rhs) long g = gcd(den, rhs); num *= rhs/g; den /= g; // fin de operator*= const Rationnel operator*(const Rationnel& gauche, const Rationnel& droite) return Rationnel(gauche) *= droite; // fin de operator* Fonction utilitaire (non membre) GPA777 (Codage C++) 20 10

11 const Rationnel& Rationnel::operator/=(const Rationnel& rhs) if (rhs == 0.0) cerr << "Division par zéro" << endl; exit(1); long g1 = gcd(num, rhs.num); long g2 = gcd(den, rhs.den); num = (num/g1) * (rhs.den/g2); den = (den/g2) * (rhs.num/g1); // Toujours mettre le signe au numérateur if (den < 0L) num = -num; den = -den; // fin de operator/= const Rationnel& Rationnel::operator/=(long rhs) if (rhs == 0L) cerr << "Division par zéro" << endl; exit(1); long g = gcd(num, rhs); num /= g; den *= rhs/g; // Toujours mettre le signe au numérateur if (den < 0L) num = -num; den = -den; // fin de operator/= GPA777 (Codage C++) 21 const Rationnel operator/(const Rationnel& gauche, const Rationnel& droite) return Rationnel(gauche) /= droite; // fin de operator/ const Rationnel& Rationnel::operator ++() return (*this += 1); // fin de operator ++ const Rationnel& Rationnel::operator --() return (*this -= 1); // fin de operator -- const Rationnel Rationnel::operator ++(int) Rationnel valeur = *this; ++(*this); return (valeur); // fin de operator ++ Pré-incrémentation Pré-décrémentation Post-incrémentation GPA777 (Codage C++) 22 11

12 const Rationnel Rationnel::operator --(int) Rationnel valeur = *this; --(*this); return (valeur); // fin de operator -- bool operator==(const Rationnel& gauche, Rationnel& droite) return (gauche.numerateur() == droite.numerateur() && gauche.denominateur() == droite.denominateur()); // fin de operator == bool operator!=(const Rationnel& gauche, Rationnel& droite) return (gauche.numerateur()!= droite.numerateur() && gauche.denominateur()!= droite.denominateur()); // fin de operator!= bool operator<(const Rationnel& gauche, Rationnel& droite) return (versdouble(gauche) < versdouble(droite)); // fin de operator < Post-décrémentation Fonctions utilitaires (non membre) GPA777 (Codage C++) 23 bool operator>(const Rationnel& gauche, Rationnel& droite) return (versdouble(gauche) > versdouble(droite)); // fin de operator > bool operator<=(const Rationnel& gauche, Rationnel& droite) return ((gauche < droite) (gauche == droite)); // fin de operator <= bool operator>=(const Rationnel& gauche, Rationnel& droite) return ((gauche > droite) (gauche == droite)); // fin de operator >= Rationnel rabs(const Rationnel& rat) if (rat.numerateur() < 0) return -rat; else return rat; Fonctions utilitaires (non membre) // fin de rabs() GPA777 (Codage C++) 24 12

13 ostream& operator<<(ostream& s, const Rationnel& r) if (r.denominateur() == 1L) s << r.numerateur(); else s << r.numerateur() << "/" << r.denominateur(); return s; // fin de << C est de cette façon que l on surcharge l opérateur << (insertion dans le flux de sortie). Ex: Rationnel rat(11, 5); : : : cout << rat << endl; GPA777 (Codage C++) 25 /* versrationnel ******************************************** * Fonction locale réalisant la conversion double -> * Rationnel. Méthode utilisée est la fraction continue. * Ex: 1 * * = = = * * * * * * * Il y aura toujours perte de précision mais c'est simple à * réaliser. * * Entrée: x (valeur double), limite, iterations * Sortie: un objet de type Rationnel * static Rationnel versrationnel(double x, double limite, int iterations) double partieentiere, partiefractionnaire = modf(x, &partieentiere); double d = 1.0 / partiefractionnaire; Conversion explicite de double vers Rationnel long reste = long(partieentiere); if (d > limite iterations == 0) return Rationnel(reste); else return Rationnel(reste) + versrationnel(d, limite *.1, --iterations).inverse(); GPA777 (Codage C++) 26 13

14 /* versrationnel ******************************************** * Fonction locale réalisant la conversion double -> * Rationnel * * Entrée: x (valeur double), iterations * Sortie: un objet de type Rationnel * static Rationnel versrationnel(double x, int iterations) if (x == 0.0 x < numeric_limits<long>::min() x > numeric_limits<long>::max()) return Rationnel(0, 1); else long signe = x < 0.0? -1 : 1; return Rationnel(signe) * versrationnel(signe * x, 1.0e12, iterations); // fin de versrationnel() La définition des fonctions membres et des fonctions utilitaires est maintenant terminée. GPA777 (Codage C++) 27 Utilisation de la classe Rationnel Génération d une série harmonique: /* Harmonique ********************************************** * Une série harmonique est définie par: H(n) = 1 + 1/2 + * 1/3 + 1/n. En exprimant ces valeurs en terme de nombres * rationnels, nous aurons une précision arbitraire. * * Entrée: n de la série harmonique * Sortie: Rationnel résultant * Rationnel Harmonique(int n) Rationnel rat = 1; for (int i=2; i<=n; i++) rat += Rationnel(1, i); return rat; // fin Harmonique() H n = L GPA777 (Codage C++) 28 n 14

15 Utilisation de la classe Rationnel Approximation de la constante de Euler par une série harmonique void TestHarmonique() cout << "n\tapproximation Euler\tHarmonique(n)" << endl; cout << "========================================" << endl; for (int n=1; n<25; n++) Rationnel r = Harmonique(n); double g = versdouble(r) - log(n); g -= (1.0/(2*n)) * (1.0 - (1.0/(6*n))); cout << n << '\t' << g << '\t' << r << endl; // fin de TestHarmonique() n Euler harmonique(n) n Euleur harmonique(n) ======================================================================================== / / / / / / / / / / / / / / / / / / / / / / / GPA777 (Codage C++) 29 Utilisation de la classe Rationnel Génération des nombres Bernoulli: æ n 1 1 = ç ( 1), 1. å n B ç n B k n + B = 0 è k= 0 è k ø ø Rationnel Binomial(int n, int k) if (n < 0) cerr << "n ne peut etre negatif" << endl; exit (1); if (k < 0 k > n) cerr << "k ne peut etre negatif ou plus grand que n" << endl; exit (1); if (k > n-k) æ n ö æ n ö æ n ö k = n-k; ç = n k + 1 k ç, ç = 1 if (k == 0) return 1; 1 è kø è k ø è kø k= 0 return Rationnel(n-k+1, k) * Binomial(n, k-1); // fin de Binomial() æ + ö ö ( ). GPA777 (Codage C++) 30 15

16 Utilisation de la classe Rationnel Génération des nombres Bernoulli (suite) Rationnel Bernoulli(int n) if (n < 0) cerr << "indice ne peut etre negatif" << endl; exit(1); else if (n == 0) return 1; else if (n == 1) return Rationnel(-1, 2); if (n % 2) return Rationnel(0, 1); Rationnel r = 0; for (int k=0; k<n; k++) r -= Binomial(n+1, k) * Bernoulli(k); r /= n+1; return r; // fin de Bernouilli() GPA777 (Codage C++) 31 Utilisation de la classe Rationnel Génération des nombres Bernoulli (suite) void TestBernoulli() cout << "n\tbernoulli(n)" << endl; cout << "====================" << endl; Rationnel b; for (int n=0; n<23; n++) if ((b=bernoulli(n))!= 0.0) cout << n << '\t' << b << endl; // fin de TestBernoulli() n Bernoulli(n) n Bernoulli(n) ============================================== / / / / / / / /42 8-1/ / / /6 GPA777 (Codage C++) 32 16

17 Environnement de développement Nous avons utilisé le VC++ 6 pour la programmation de cette classe. Le projet de programmation est du type «Win32 console application». Les fichiers créés sont rangés de cette façon: Rationnel.h (.cpp): déclaration et définition de la classe Rationnel. ProgPrincipal.cpp: fonction main() et les routines pour l approximation de constante d Euler et la génération des nombres de Bernoulli. StdAfx.h (.cpp): fichiers nécessaires pour la précompilation des fichiers d en-tête de VC++. ReadMe.txt: description du contenu de ce projet de programmation. Page web: GPA777 (Codage C++) 33 17