voici un code en c++#include "Fixed.hpp" int Fixed::getRawBits( void ) const { std::cout…
- User
voici un code en c++#include "Fixed.hpp"
int Fixed::getRawBits( void ) const { std::cout << "getRawBits member function called" << std::endl; return (Integer); }
void Fixed::setRawBits( int const raw ) { Integer = raw; } #include #include "Fixed.hpp"
int main (void) { Fixed a; Fixed b(a); Fixed c; c = b; std::cout << a.getRawBits() << std::endl; std::cout << b.getRawBits() << std::endl; std::cout << c.getRawBits() << std::endl; return (0); } #ifndef FIXED_HPP #define FIXED_HPP
include
include
include
class Fixed { private: int Integer; static const int IntegerStatic = 8; public: //constructeur par defaut Fixed() : Integer(0) { std::cout << "Default constructor called" << std::endl; } //constructeur de copie Fixed(const Fixed &autre) : Integer(autre.Integer) { std::cout << "Copy constructor called" << std::endl; getRawBits(); } //constructeur qui prend un int et qui le passe en /Fixed(int number) : Integer(autre.Integer) { std::cout << "Copy constructor called" << std::endl; getRawBits(); }/ //surcharge Fixed& operator=(const Fixed& autre) { if (this != &autre) { Integer = autre.Integer; } std::cout << "Copy assignment operator called" << std::endl; return *this; } //destructeur ~Fixed() { std::cout << "Destructor called" << std::endl; } int getRawBits( void ) const; void setRawBits( int const raw ); };
#endif j aimerais que tu rajoute ca Un constructeur prenant un entier constant en paramètre et qui convertit celuici en virgule fixe. Le nombre de bits de la partie fractionnaire est initialisé à 8 comme dans l’exercice 00.
- Assistant
Pour implémenter un constructeur prenant un entier constant en paramètre et le convertissant en virgule fixe, voici les modifications à apporter. Ce constructeur utilisera le fait que la partie fractionnaire de la représentation en virgule fixe utilise 8 bits par défaut (comme précisé dans l'exercice 00). Cela signifie que vous allez décaler l'entier reçu à gauche de 8 bits.
Voici les modifications et ajouts nécessaires dans votre code :
Mise à jour du fichier
Fixed.hppAjoutez ce nouveau constructeur à la classe
Fixeddéfinie dansFixed.hpp:// Nouveau constructeur prenant un entier constant en paramètre Fixed(int number);Cela informera le compilateur qu’un tel constructeur existe.
Mise à jour du fichier
Fixed.cppAjoutez l’implémentation de votre nouveau constructeur dans le fichier source (
Fixed.cpp), comme suit :// Constructeur prenant un entier constant en paramètre Fixed::Fixed(int number) { std::cout << "Int constructor called" << std::endl; this->Integer = number << IntegerStatic; // Conversion en virgule fixe (8 bits pour la partie fractionnaire) }Dans ce cas, un entier passé en paramètre est décalé vers la gauche de
IntegerStatic(8 bits), ce qui est équivalent à multiplier le nombre par (2^8), pour créer une représentation en virgule fixe.
(Étape facultative) Si vous voulez gérer également des
float:Un constructeur similaire pourrait être ajouté pour gérer un nombre flottant (
float). Cela irait de pair avec votre exercice. Voici comment cela pourrait paraître (bonus) :// Nouveau constructeur prenant un flottant constant en paramètre Fixed(float number) { std::cout << "Float constructor called" << std::endl; this->Integer = roundf(number * (1 << IntegerStatic)); // Conversion et arrondi }
Exemple de test dans
main.cppAjoutez du code pour tester le nouveau constructeur dans votre fonction
main:int main(void) { Fixed a; Fixed b(a); Fixed c; c = b; Fixed d(42); // Utilisation du constructeur prenant un entier std::cout << "Fixed d created with value 42 in int: " << d.getRawBits() << std::endl; std::cout << a.getRawBits() << std::endl; std::cout << b.getRawBits() << std::endl; std::cout << c.getRawBits() << std::endl; return (0); }Cela vérifiera que le constructeur prenant un entier fonctionne correctement et effectue la conversion attendue.
Code complet mis à jour :
Fixed.hpp#ifndef FIXED_HPP #define FIXED_HPP # include <iostream> # include <cmath> class Fixed { private: int Integer; static const int IntegerStatic = 8; public: // Constructeurs Fixed(); // Constructeur par défaut Fixed(const Fixed &autre); // Constructeur de copie Fixed(int number); // Constructeur prenant un entier Fixed(float number); // (Bonus) Constructeur prenant un flottant ~Fixed(); // Destructeur // Surcharge d'opérateurs Fixed& operator=(const Fixed& autre); // Accesseurs int getRawBits(void) const; void setRawBits(int const raw); }; #endif
Code complet mis à jour :
Fixed.cpp#include "Fixed.hpp" // Constructeur par défaut Fixed::Fixed() : Integer(0) { std::cout << "Default constructor called" << std::endl; } // Constructeur de copie Fixed::Fixed(const Fixed &autre) : Integer(autre.Integer) { std::cout << "Copy constructor called" << std::endl; } // Constructeur prenant un entier constant Fixed::Fixed(int number) { std::cout << "Int constructor called" << std::endl; this->Integer = number << IntegerStatic; // Conversion en virgule fixe } // (Optionnel) Constructeur prenant un flottant Fixed::Fixed(float number) { std::cout << "Float constructor called" << std::endl; this->Integer = roundf(number * (1 << IntegerStatic)); // Conversion avec arrondi } // Destructeur Fixed::~Fixed() { std::cout << "Destructor called" << std::endl; } // Surcharge d'opérateurs pour l'opérateur d'affectation Fixed& Fixed::operator=(const Fixed& autre) { if (this != &autre) { this->Integer = autre.Integer; } std::cout << "Copy assignment operator called" << std::endl; return *this; } // Méthode getRawBits int Fixed::getRawBits(void) const { std::cout << "getRawBits member function called" << std::endl; return this->Integer; } // Méthode setRawBits void Fixed::setRawBits(int const raw) { this->Integer = raw; }
Résultat attendu lors de l’exécution
Avec ce code, votre programme devrait produire les résultats suivants lors de l’exécution (selon vos tests dans
main) :Default constructor called Copy constructor called Copy assignment operator called Destructor called Int constructor called Fixed d created with value 42 in int: 10752 getRawBits member function called 0 getRawBits member function called 0 getRawBits member function called 0 Destructor called Destructor called Destructor called Destructor called
Cela inclut maintenant la fonctionnalité demandée, avec un constructeur qui accepte un entier et effectue la conversion en virgule fixe en utilisant une partie fractionnaire de 8 bits.
- User
explique moi ca un peux mieux Fixed::Fixed(int number) { std::cout << "Int constructor called" << std::endl; this->Integer = number << IntegerStatic; // Conversion en virgule fixe (8 bits pour la partie fractionnaire) }
- Assistant
Bien sûr ! Approfondissons ensemble cette partie du code pour mieux comprendre ce qu'elle fait.
Fixed::Fixed(int number) { std::cout << "Int constructor called" << std::endl; this->Integer = number << IntegerStatic; // Conversion en virgule fixe (8 bits pour la partie fractionnaire) }1. Contexte
Le but de ce constructeur est de convertir un entier (
int) en représentation fixe en virgule (fixed-point representation), dans laquelle 8 bits sont réservés pour la partie fractionnaire.- En virgule fixe, les nombres ne sont pas représentés en flottants (comme les doubles ou floats), mais en entiers avec une partie entière et une partie fractionnaire simulée par un décalage.
- Dans ce cas, vous avez décidé que 8 bits (1 octet) des 32 bits (d’un entier de type
int) seront utilisés pour stocker la partie fractionnaire. Cela signifie que la représentation fixe traitera l'entier comme si 8 bits correspondaient à la position décimale.
2. Comment fonctionne
<< IntegerStatic?L'opérateur
<<(décalage à gauche) déplace tous les bits d'une valeur entière vers la gauche d'un certain nombre de positions. En d'autres termes, cela multiplie la valeur par ( 2^{n} ) oùnest le nombre de positions de décalage.
3. Cas pratique : Conversion en virgule fixe
Dans le contexte du constructeur, lorsqu'un entier
numberest donné, la ligne suivante effectue la conversion :this->Integer = number << IntegerStatic;Cela signifie que la valeur entière
numberest multipliée par ( 2^{8} = 256 ). Le résultat représente le nombre en virgule fixe, où 8 bits sont réservés pour la partie fractionnaire.- La raison : En décalant l'entier à gauche, vous préparez l'espace à droite (les 8 bits inférieurs) pour représenter une fraction plus tard si nécessaire.
4. Exemple détaillé
Prenons une valeur
number = 42(en base 10) pour explorer ce qui se passe à chaque étape.Étape 1 : Représentation binaire normale
En binaire, la valeur entière
42correspond à :42 = 101010 (en binaire)Les bits sont actuellement alignés pour représenter juste l'entier, sans fraction.
Étape 2 : Décalage vers la gauche
On effectue le décalage à gauche de 8 bits (avec
<< 8), ce qui est équivalent à une multiplication par (2^8 = 256).42 << 8 = 42 * 256 = 10752En binaire :
Avant (en binaire) : 00000000 00000000 00101010 Après (en binaire) : 00101010 00000000Cela signifie que l'information a été décalée pour laisser 8 bits prêts à représenter une partie fractionnaire dans des calculs futurs.
5. Conclusion sur l'effet
Ce constructeur fait en sorte qu'un nombre entier, comme
42, soit transformé dans une représentation adaptée pour des calculs en virgule fixe avec 8 bits pour la partie fractionnaire. La logique est la suivante :- L'entier de départ est traité comme entier pointé sur la partie entière dans le monde des nombres en virgule fixe.
- La multiplication par (256) (ou décalage gauche par 8 bits) s'assure que les 8 bits inférieurs sont initialisés à 0 et peuvent représenter une fraction ultérieure.
Veillez à noter que, pour revenir à une représentation humaine compréhensible (valeur réelle en décimal), vous devrez plus tard décaler à droite de 8 bits ou diviser par (256) dans d'autres fonctions de conversion.
6. Comparaison : Avec et Sans Décalage
Si vous ne faisiez pas le décalage à gauche lors de la conversion :
- La partie fractionnaire ne pourrait pas être simulée avec uniquement des entiers.
- Différentes opérations basées sur des calculs en virgule fixe (par exemple, addition, multiplication) pourraient donner des résultats erronés ou incohérents.
L'approche avec décalage garantit que l'entier est préparé pour fonctionner dans un système en virgule fixe avec une précision de 8 bits.
Est-ce plus clair ? Si des points restent flous ou si vous voulez explorer davantage un aspect précis, n'hésitez pas à me le faire savoir ! 😊
- User
une fonction pour le reconvertir: es que elle marche: float Fixed::toFloat(void) const; { float FloatNmuber;
FloatNmuber = Integer >> IntegerStatic return (FloatNmuber);}
- Assistant
Non, la fonction que vous proposez ne fonctionnera pas correctement. Elle contient des erreurs importantes, à la fois sur le plan de la syntaxe et de la logique :
Pourquoi la version ne fonctionne pas ?
Voici votre version de la fonction :
float Fixed::toFloat(void) const; { float FloatNmuber; FloatNmuber = Integer >> IntegerStatic return (FloatNmuber); }Problèmes dans le code ci-dessus :
-
Erreur de syntaxe :
- Il y a un point-virgule (
;) aprèsfloat Fixed::toFloat(void) const;. Cela ne devrait pas être là. Ce point-virgule fait que le compilateur suppose que la fonction est une déclaration et ignore le corps de la fonction. Retirez ce point-virgule.
- Il y a un point-virgule (
-
Opération incorrecte pour la conversion en virgule flottante :
- L'utilisation de l'opérateur
>> IntegerStaticeffectue un décalage binaire à droite, mais ce n'est pas ce que vous voulez pour convertir un nombre en virgule fixe (Integer) en un nombre flottant. - Décaler un entier à droite divise par (2^{IntegerStatic}), mais il effectue une division entière, ce qui supprime toute partie fractionnaire (précision perdue).
- L'utilisation de l'opérateur
-
Oubliez
float FloatNmuber:- Il n'y a pas besoin de créer une variable temporaire comme
FloatNmuber. Vous pouvez directement effectuer les calculs et retourner le résultat.
- Il n'y a pas besoin de créer une variable temporaire comme
-
Manque une conversion explicite en nombre flottant :
Integerest un entier. Lorsque vous retournez le résultat, il doit être dans un format flottant, donc vous devez le convertir explicitement enfloatpour que la division fournisse une fraction précise.
Solution corrigée : Conversion correcte en
floatLa conversion en nombre flottant devrait être réalisée en divisant la valeur entière de
Integerpar (2^{IntegerStatic}) pour "annuler" l'effet de la conversion en virgule fixe (ce qui avait fait un décalage à gauche).float Fixed::toFloat(void) const { return static_cast<float>(Integer) / (1 << IntegerStatic); // Division par 2^8 (256) }Explications de chaque élément :
-
static_cast<float>(Integer):Integerest un entier (typeint) qui contient la représentation en fixe (partie entière décalée de 8 bits).- En le convertissant explicitement (
static_cast), on s'assure que les calculs suivants ont lieu en virgule flottante (float), pas en entier.
-
Division par
(1 << IntegerStatic):1 << IntegerStaticeffectue une multiplication par 2 puissance 8 ((2^8)), équivalente à (256).- Ainsi, lorsque vous divisez par (256), vous annulez l'effet du décalage de 8 bits qui avait été appliqué dans le constructeur à l'entrée.
-
Pas besoin de variable intermédiaire :
- Le calcul est simple et peut être retourné directement sans nécessiter une variable temporaire.
Exemple visuel :
Imaginons que vous avez un entier en virgule fixe (
Integer) représentant le nombre42.5. Voyons ce qui se passe.Étape 1 : Le nombre en virgule fixe
Si vous avez ( 42.5 ), lors de la conversion en virgule fixe (dans le constructeur), il a été enregistré ainsi :
Integer = 42.5 * 256 = 10880L'entier
10880stocke la représentation fixe de la valeur réelle.
Étape 2 : Revenir à un réel (float)
Lors de la conversion inverse dans
toFloat():static_cast<float>(10880) / 256.0f = 42.5Le nombre flottant
42.5est ainsi retrouvé avec précision.
Cas complet avec test dans
mainVoici un exemple de test pour tous les cas :
Code principal (
main.cpp) :int main(void) { Fixed a(42); // Conversion depuis un entier Fixed b(42.75f); // Conversion depuis un flottant (bonus si vous avez implémenté le constructeur) Fixed c(a); // Test du constructeur de copie std::cout << "a as float: " << a.toFloat() << std::endl; std::cout << "b as float: " << b.toFloat() << std::endl; std::cout << "c as float: " << c.toFloat() << std::endl; return 0; }Résultat attendu :
Int constructor called Float constructor called Copy constructor called a as float: 42 b as float: 42.75 c as float: 42 Destructor called Destructor called Destructor called
Conclusion
La fonction corrigée et vérifiée pour reconvertir un entier fixe en flottant :
float Fixed::toFloat(void) const { return static_cast<float>(Integer) / (1 << IntegerStatic); }Vous garantissez ainsi une conversion précise et cohérente entre les valeurs flottantes et leur représentation fixe. 😊
Si vous avez d'autres questions ou des cas spécifiques à clarifier, n'hésitez pas !
-
- User
explique moi mieux cette partie / (1 << IntegerStatic)
- Assistant
Bien sûr ! Plongeons dans
/ (1 << IntegerStatic)pour bien comprendre son rôle et son fonctionnement dans votre contexte.
CONTEXTE : Pourquoi cette division ?
Le but ici est de revenir à une représentation "normale" en flottant à partir d'un nombre stocké en format virgule fixe.
- En virgule fixe, vous avez décalé les bits de l'entier
Integerde 8 bits vers la gauche (via << 8), pour convertir la valeur en virgule fixe.- Par exemple : Lorsqu'un entier comme
42a été décalé, il est devenu42 * 2^8 = 10752.
- Par exemple : Lorsqu'un entier comme
- La division "/ (1 << IntegerStatic)" a donc pour objectif de annuler cet effet de décalage, et de transformer la valeur en virgule flottante (float).
EXPLICATION PAS À PAS : Que fait
(1 << IntegerStatic)?1 << IntegerStaticsignifie "Décale le bit 1 de IntegerStatic positions vers la gauche".
Cela vous donne une valeur équivalente à (2^{IntegerStatic}), oùIntegerStatic = 8dans votre exemple.- ( 1 <<= 8 \longrightarrow 2^8 = 256 )
Ainsi,
(1 << IntegerStatic)est simplement une manière élégante et compacte d’écrire 256 sans utiliser la puissance ((2^n)) directement.
COMMENT fonctionne
/ (1 << IntegerStatic)?Lorsqu'on divise par (256 = 2^8), on restaure le placement des bits dans leur position d'origine, permettant de revenir à un nombre normal à virgule flottante.
- Les 8 bits qui représentaient la partie décimale sont placés correctement après avoir divisé par (256).
- Cela annule la transformation en virgule fixe effectuée au départ.
EXEMPLE VISUEL POUR COMPRENDRE
Prenons un exemple simple avec :
IntegerStatic = 8- Le convertisseur en virgule fixe
Integercontient la représentation décimale du nombre42.75:
( Integer = 42.75 * 256 = 10944 ).
Étape 1 : Décodage de la représentation actuelle (fixe)
En binaire, l'entier
10944est :10944 = 10101010 00000000 (binaire sur 16 bits)- Les 8 bits de gauche (les plus significatifs) correspondent à la partie entière (
42). - Les 8 bits de droite (les moins significatifs) représentent la partie fractionnaire (
0.75).
Étape 2 : Re-diviser pour revenir à un vrai flottant
On veut retransformer
10944en son format d'origine avec la formule :[ \text{float result} = \frac{\text{Integer}}{256} ]
En opérant :
[ \frac{10944}{256} = 42.75 ]
Cela nous ramène bien au résultat attendu dans un format flottant.
Dans le code :
float Fixed::toFloat(void) const { return static_cast<float>(this->Integer) / (1 << IntegerStatic); }
POURQUOI UTILISER
(1 << IntegerStatic)AU LIEU DE SIMPLEMENT ÉCRIRE256?L'utilisation de
(1 << IntegerStatic)offre plusieurs avantages :-
Lisibilité et flexibilité :
- Le code utilise la valeur de
IntegerStaticdirectement, qui est unstatic constdans votre classe. - Cela signifie que si vous changez un jour la partie fractionnaire à 10 bits (au lieu de 8), vous n'aurez pas besoin de remplacer manuellement
256dans tout le code. - Il suffira de changer
IntegerStatic = 10dans votre classe, et tout le code se mettra à jour automatiquement.
- Le code utilise la valeur de
-
Évite les erreurs humaines :
- Si vous écrivez directemment
256partout dans le code, il peut être facile de faire une erreur, par exemple : Écrire accidentellement 255 ou 512. Avec1 << IntegerStatic, le calcul est programmatique et sécurisé.
- Si vous écrivez directemment
-
Performances :
- Les décalages binaires (
<<) sont extrêmement rapides à exécuter en C++ (plus rapides que calculer manuellement une puissance comme (2^n)).
- Les décalages binaires (
AUTRE EXEMPLE PRATIQUE
Prenons un autre exemple : Un nombre entier stocké sous virgule fixe, et essayons de le reconvertir.
Cas : Nombre plus petit (12.34)
-
Lors de la construction :
- ( Integer = 12.34 \times 256 = 3163 )
- Représentation :
3163est converti en virgule fixe.
-
Lors de la conversion float avec
toFloat():- On divise par (256 = 1 << 8) : [ \text{FloatNmuber} = \frac{3163}{256} = 12.34 ]
Cette opération ramène bien la valeur d'origine.
Résumé
1. CE QUE FAIT
(1 << IntegerStatic)- Équivaut à (2^{IntegerStatic}).
- Avec
IntegerStatic = 8, cela donne (256).
2. POURQUOI DIVISER PAR
(1 << IntegerStatic)?- Car c'est l'inverse de l'opération effectuée pour convertir un entier en virgule fixe (ce qui consiste à décaler les bits avec
<< 8). - Cela restaure la partie décimale correctement.
3. AVANTAGES DE
(1 << IntegerStatic):- Lisibilité et flexibilité (modifiez facilement le nombre de bits fractionnaires).
- Plus sûr que d'utiliser une constante fixe comme
256. - Performances optimales.
Si quelque chose reste flou, je suis là pour clarifier davantage ! 😊
- En virgule fixe, vous avez décalé les bits de l'entier
- User
Ajoutez également la fonction suivante à vos fichiers de la classe Fixed : • Une surcharge de l’opérateur d’insertion («) qui insère une représentation en virgule flottante du nombre à virgule fixe dans le flux de sortie (objet output stream) passé en paramètre.
- Assistant
Pour implémenter cette demande, nous allons ajouter une surcharge de l'opérateur d'insertion (
<<) afin de permettre à la classeFixedd'afficher directement une représentation en virgule flottante d'un nombre en virgule fixe dans le flux de sortie. Cela signifie que lorsqu'on faitstd::cout << fixedObject;, l'objetFixedsera affiché en tant que nombre décimal compréhensible (grâce à son équivalent en float).Étapes à suivre
1. Prototyper l'opérateur
<<dansFixed.hppAjoutez un prototype pour la surcharge de l'opérateur dans votre fichier
Fixed.hpp.Voici comment le déclarer :
// À ajouter dans Fixed.hpp friend std::ostream& operator<<(std::ostream& out, const Fixed& value);Remarque importante :
- L'opérateur
<<n'est pas une méthode membre de la classeFixed, car son premier argument doit être le flux de sortie (std::ostream&). Par conséquent, on utilise un ami de la classe (friend) pour lui donner un accès aux membres privés deFixed.
2. Définir l’opérateur dans
Fixed.cppEnsuite, dans
Fixed.cpp, définissez le comportement de l'opérateur<<pour afficher correctement une représentation en virgule flottante du nombre stocké dans un objet de typeFixed.Voici la définition :
#include "Fixed.hpp" // Surcharge de l'opérateur d'insertion << std::ostream& operator<<(std::ostream& out, const Fixed& value) { out << value.toFloat(); // Appelle la méthode toFloat() pour obtenir la représentation en float return out; }Détails :
-
out << value.toFloat();:- Cette ligne appelle la méthode
toFloat()déjà définie dans votre classeFixed, qui renvoie une représentation en float (nombres décimaux) de l'objetvalueen virgule fixe. - Ensuite, la valeur flottante obtenue est insérée dans le flux de sortie (
out).
- Cette ligne appelle la méthode
-
return out;:- On retourne le flux de sortie (
std::ostream) afin de permettre des chaînes d'opérations comme :std::cout << fixedObject1 << " value is: " << fixedObject2 << std::endl;
- On retourne le flux de sortie (
3. Test dans
mainVous pouvez maintenant tester le comportement de la surcharge
<<dans le programme principal (fichiermain.cpp). Par exemple :int main(void) { Fixed a(42); // Utilise le constructeur prenant un entier Fixed b(42.75f); // Utilise le constructeur prenant un flotant Fixed c = a; // Test du constructeur par affectation std::cout << "a: " << a << std::endl; // Devrait afficher 42.0 std::cout << "b: " << b << std::endl; // Devrait afficher 42.75 std::cout << "c: " << c << std::endl; // Devrait afficher 42.0 return 0; }Résultat attendu :
Int constructor called Float constructor called Copy constructor called a: 42 b: 42.75 c: 42 Destructor called Destructor called Destructor called
Résumé des fichiers après modification
Fixed.hppAjoutez le prototype suivant :
friend std::ostream& operator<<(std::ostream& out, const Fixed& value);Cela rendra l'opérateur accessible au flux de sortie.
Fixed.cppAjoutez l'implémentation de l'opérateur
<<:#include "Fixed.hpp" // Surcharge de l'opérateur d'insertion << std::ostream& operator<<(std::ostream& out, const Fixed& value) { out << value.toFloat(); // Conversion en float avant affichage return out; }
Voilà ! Grâce à cette fonction, vous pouvez afficher directement vos objets
Fixeden flux tel questd::cout! 😊 Si des clarifications supplémentaires sont nécessaires, n'hésitez pas à demander. - L'opérateur
- User
┌──(overlord㉿Overlord)-[~/Bureau/cpp02/ex01] └─$ make c++ -Wall -Werror -Wextra -std=c++98 -c main.cpp -o obj/main.o c++ -Wall -Werror -Wextra -std=c++98 -c Fixed.cpp -o obj/Fixed.o Fixed.cpp:19:5: error: declaration of ‘int Fixed::toInt() const’ outside of class is not definition [-fpermissive] 19 | int Fixed::toInt(void) const; | ^~~~~ Fixed.cpp:20:1: error: expected unqualified-id before ‘{’ token 20 | { | ^ make: *** [Makefile:25 : obj/Fixed.o] Erreur 1
- Assistant
Voici les raisons des erreurs que vous rencontrez et comment les résoudre :
1. Erreur signalée :
Fixed.cpp:19:5: error: declaration of ‘int Fixed::toInt() const’ outside of class is not definition [-fpermissive] 19 | int Fixed::toInt(void) const;Cause : La déclaration
int Fixed::toInt(void) const;dansFixed.cppn'est pas suivie immédiatemment d'une implémentation de cette fonction. Cela signifie que vous avez probablement utilisé un point-virgule (;) après le début de la définition, ce qui fait croire au compilateur que cette ligne est uniquement une déclaration (et non une définition de la fonction).
Exemple erroné :
int Fixed::toInt(void) const; // Indique une déclaration mais ne donne pas le contenu { return (this->Integer >> IntegerStatic); // Cela provoque une erreur }Ici, la ligne avec
;est incorrecte. Elle déclare la méthode mais l'empêche d'être directement définie.Solution correcte :
La fonction doit être définie sans le point-virgule. Supprimez donc le;après la signature de la méthode :int Fixed::toInt(void) const { return (this->Integer >> IntegerStatic); // Convertir les bits en entier }
2. Erreur signalée :
Fixed.cpp:20:1: error: expected unqualified-id before ‘{’ token 20 | { | ^Cause : Cette erreur est une conséquence directe du problème précédent. Lorsque le compilateur rencontre le
{après une "déclaration" qui n'est pas suivie d'une définition attendue (à cause du point-virgule), il ne sait pas comment traiter le{.Le compilateur signale donc que le
{est inattendu à cet endroit.Solution : Correction du problème précédent corrigera automatiquement celui-ci.
3. Actions détaillées pour corriger le problème
Pour implémenter et corriger correctement la méthode
toInt, procédez comme suit :-
Dans le fichier
Fixed.hpp(le fichier d'en-tête) : Assurez-vous que la méthode est bien déclarée comme :int toInt(void) const;Cela déclare la fonction pour qu'elle puisse être définie dans votre fichier source.
-
Dans le fichier
Fixed.cpp(le fichier source) : Implémentez ensuite la méthode sans utiliser le point-virgule après la signature :#include "Fixed.hpp" int Fixed::toInt(void) const { return (this->Integer >> IntegerStatic); // Convertir le Fixed Point en entier }Détails sur le calcul :
this->Integer: Représente la valeur stockée en virgule fixe.>> IntegerStatic: Décalage binaire vers la droite (opération inverse de<<). SiIntegerStatic = 8, cela divise efficacement par (2^8 = 256), retournant la partie "entière" de la valeur en Fixed-point.
Exemple complet pour éviter toute confusion
Voici un exemple clair et fonctionnel comprenant une définition minimale des fichiers affectés :
Fichier : Fixed.hpp
#ifndef FIXED_HPP #define FIXED_HPP #include <iostream> #include <cmath> class Fixed { private: int Integer; // Stock la valeur en Fixed-point static const int IntegerStatic = 8; public: Fixed(); // Constructeur par défaut Fixed(const Fixed ©); // Constructeur de copie ~Fixed(); // Destructeur Fixed &operator=(const Fixed &); // Assignation int toInt(void) const; // Convertit en entier float toFloat(void) const; // Convertit en flottant int getRawBits(void) const; void setRawBits(int const raw); }; std::ostream &operator<<(std::ostream &out, const Fixed &value); #endif
Fichier : Fixed.cpp
#include "Fixed.hpp" // Constructeurs / Destructeur Fixed::Fixed() : Integer(0) { std::cout << "Default constructor called" << std::endl; } Fixed::Fixed(const Fixed ©) : Integer(copy.Integer) { std::cout << "Copy constructor called" << std::endl; } Fixed::~Fixed() { std::cout << "Destructor called" << std::endl; } Fixed &Fixed::operator=(const Fixed &other) { std::cout << "Copy assignment operator called" << std::endl; if (this != &other) this->Integer = other.Integer; return (*this); } // Méthodes int Fixed::toInt(void) const { // Décale à droite de 8 bits pour récupérer juste la partie entière return (this->Integer >> IntegerStatic); } float Fixed::toFloat(void) const { // Divise par 2^8 pour reconstituer une valeur réelle return static_cast<float>(this->Integer) / (1 << IntegerStatic); } int Fixed::getRawBits(void) const { return this->Integer; } void Fixed::setRawBits(int const raw) { this->Integer = raw; } // Surcharge de l'opérateur d'insertion std::ostream &operator<<(std::ostream &out, const Fixed &value) { out << value.toFloat(); return out; }
Fichier : main.cpp
#include "Fixed.hpp" int main(void) { Fixed a; Fixed b(42); // Utilise un constructeur prenant un entier Fixed c(42.42f); // Utilise un constructeur prenant un float Fixed d(b); a = Fixed(1234.4321f); std::cout << "a is " << a << std::endl; std::cout << "b is " << b << std::endl; std::cout << "c is " << c << std::endl; std::cout << "d is " << d << std::endl; std::cout << "a is " << a.toInt() << " as integer" << std::endl; std::cout << "b is " << b.toInt() << " as integer" << std::endl; return 0; }
Résultat attendu lors de l'exécution
Default constructor called Int constructor called Float constructor called Copy constructor called Default constructor called Float constructor called Copy assignment operator called Destructor called a is 1234.43 b is 42 c is 42.4219 d is 42 a is 1234 as integer b is 42 as integer Destructor called Destructor called Destructor called Destructor called
Résumé des changements
- Supprimez le
;après la déclaration detoIntdansFixed.cpp. - Assurez-vous que les méthodes et classes sont correctement reliées pour la déclaration (dans
.hpp) et définition (dans.cpp).
Si vous avez besoin d'explications supplémentaires, n'hésitez pas ! 😊
-
- User
voila le code: ┌──(overlord㉿Overlord)-[~/Bureau/cpp02/ex01] └─$ cat *.cpp *.hpp #include "Fixed.hpp"
int Fixed::getRawBits( void ) const { std::cout << "getRawBits member function called" << std::endl; return (Integer); }
void Fixed::setRawBits( int const raw ) { Integer = raw; }
float Fixed::toFloat(void) const { return (static_cast(Integer) / (1 << IntegerStatic)); }
int Fixed::toInt(void) const; { return ((Integer) / (1 << IntegerStatic)); } #include #include "Fixed.hpp"
int main( void ) { Fixed a; Fixed const b( 10 ); Fixed const c( 42.42f ); Fixed const d( b ); a = Fixed( 1234.4321f ); std::cout << "a is " << a << std::endl; std::cout << "b is " << b << std::endl; std::cout << "c is " << c << std::endl; std::cout << "d is " << d << std::endl; std::cout << "a is " << a.toInt() << " as integer" << std::endl; std::cout << "b is " << b.toInt() << " as integer" << std::endl; std::cout << "c is " << c.toInt() << " as integer" << std::endl; std::cout << "d is " << d.toInt() << " as integer" << std::endl; return 0; } #ifndef FIXED_HPP #define FIXED_HPP
include
include
include
class Fixed { private: int Integer; static const int IntegerStatic = 8; public: //constructeur par defaut Fixed() : Integer(0) { std::cout << "Default constructor called" << std::endl; } //constructeur de copie Fixed(const Fixed &autre) : Integer(autre.Integer) { std::cout << "Copy constructor called" << std::endl; getRawBits(); } //constructeur qui prend un int et qui le passe en virgule fixe Fixed(int number) { std::cout << "Int constructor called" << std::endl; this->Integer = number << IntegerStatic; // Conversion en virgule fixe (8 bits pour la partie fractionnaire) } //constructeur qui prend un int et qui le passe en virgule fixe Fixed(float number) { std::cout << "Int constructor called" << std::endl; this->Integer = static_cast(number) <<IntegerStatic; // Conversion en virgule fixe (8 bits pour la partie fractionnaire) } //surcharge Fixed& operator=(const Fixed& autre) { if (this != &autre) { Integer = autre.Integer; } std::cout << "Copy assignment operator called" << std::endl; return *this; } //destructeur ~Fixed() { std::cout << "Destructor called" << std::endl; } int getRawBits( void ) const; void setRawBits( int const raw ); float toFloat(void) const; int toInt(void) const; friend std::ostream& operator<<(std::ostream& out, const Fixed& value); };
#endif et voila l erreur ┌──(overlord㉿Overlord)-[~/Bureau/cpp02/ex01] └─$ make c++ -Wall -Werror -Wextra -std=c++98 -c Fixed.cpp -o obj/Fixed.o Fixed.cpp:19:5: error: declaration of ‘int Fixed::toInt() const’ outside of class is not definition [-fpermissive] 19 | int Fixed::toInt(void) const; | ^~~~~ Fixed.cpp:20:1: error: expected unqualified-id before ‘{’ token 20 | { | ^ make: *** [Makefile:25 : obj/Fixed.o] Erreur 1
┌──(overlord㉿Overlord)-[~/Bureau/cpp02/ex01] └─$
- Assistant
La cause principale de l'erreur vient de comment vous avez défini votre fonction
toIntdansFixed.cpp:Vous avez écrit ceci dans
Fixed.cpp:int Fixed::toInt(void) const; { return ((Integer) / (1 << IntegerStatic)); }Problème #1 : Point-virgule (
;) après la signature de la méthodeLa présence du point-virgule (
;) aprèsint Fixed::toInt(void) constindique au compilateur que c’est uniquement une déclaration de méthode, et non l'implémentation de la fonction. Cela explique le message :Fixed.cpp:19:5: error: declaration of 'int Fixed::toInt() const' outside of class is not definitionEn gros, le
{ ... }qui suit cette déclaration est considéré comme indépendant et provoque une erreur de syntaxe, car le compilateur croit que cela doit être l'implémentation d'une autre fonction.
Solution
Supprimez le point-virgule après la signature de la fonction dans
Fixed.cpp.Voici la version corrigée :
int Fixed::toInt(void) const { return (Integer >> IntegerStatic); // Décalage à droite pour récupérer la partie entière }
Problème #2 : Division dans
toIntVous utilisez temporairement une division dans votre méthode
toInt:return ((Integer) / (1 << IntegerStatic));Cela fonctionne correctement, mais une division est légèrement plus coûteuse que l'utilisation d’un décalage binaire (ce que vous auriez dû utiliser ici). Comme dans le constructeur, vous avez converti un entier en représentation Fixed Point en utilisant un décalage gauche (
<<), il est plus cohérent et plus rapide d’annuler cette opération avec un décalage droit (>>).Corrigez la ligne :
return (Integer >> IntegerStatic);Cela décale les bits de la valeur de retour vers la droite de
IntegerStatic = 8positions, annulant parfaitement l'effet inverse (le décalage gauche du constructeur).
Fonctionnement global de
toIntLorsqu’il est corrigé,
toIntdevrait :- Prendre l'entier interne
Integer(qui est en format virgule fixe). - Décaler les bits à droite de
IntegerStatic = 8pour récupérer la partie entière originale. - Retourner le résultat en tant qu'entier (type
int).
Code corrigé dans Fixed.cpp (partie concernée)
Voici la version corrigée complète :
float Fixed::toFloat(void) const { return (static_cast<float>(Integer) / (1 << IntegerStatic)); // Convertit en flottant } int Fixed::toInt(void) const { return (Integer >> IntegerStatic); // Décalage à droite pour retrouver la partie entière }
Test de fonctionnement
Vous avez aussi inclus un test dans le fichier
main.cpp:Une fois corrigé, attendez-vous aux résultats suivants dans votre
main.cpp:Votre test :
std::cout << "a is " << a.toInt() << " as integer" << std::endl; std::cout << "b is " << b.toInt() << " as integer" << std::endl; std::cout << "c is " << c.toInt() << " as integer" << std::endl; std::cout << "d is " << d.toInt() << " as integer" << std::endl;Si tout est corrigé, les résultats devraient ressembler à cela :
a is 1234 as integer b is 10 as integer c is 42 as integer d is 10 as integer
Vérifiez les autres parties de votre code
D'autres parties de votre code semblent correctes, à part cette erreur de syntaxe. Mais par précaution, vérifiez :
-
Les autres méthodes déclarées dans
Fixed.hppet définies dansFixed.cpp:- Assurez-vous qu'il n'y a pas d’autre point-virgule (
;) mal placé après la signature d'une fonction. - Exemple :
toFloat,getRawBits,setRawBitssemblent corrects.
- Assurez-vous qu'il n'y a pas d’autre point-virgule (
-
Le constructeur qui prend un float :
Il y a une erreur subtile : vous perdez la partie décimale lors de la conversion.
Fixed(float number) { std::cout << "Int constructor called" << std::endl; this->Integer = static_cast<int>(number) << IntegerStatic; // Problème ici }- En utilisant
static_cast<int>(number), vous supprimez toute la fraction flottante et ne stockez que la partie entière.
Remplacez cette ligne par :
this->Integer = roundf(number * (1 << IntegerStatic));- Cela convertit correctement la valeur flottante en représentation fixe (avec arrondi pour préserver la précision).
- En utilisant
Makefile et relance
Après avoir corrigé les erreurs, exécutez :
make clean make ./program_nameSi vous rencontrez d'autres problèmes, n'hésitez pas à demander leur résolution. 😊
- Prendre l'entier interne
- User
maintenant sa me fait ca ┌──(overlord㉿Overlord)-[~/Bureau/cpp02/ex01] └─$ make c++ -Wall -Werror -Wextra -std=c++98 -c Fixed.cpp -o obj/Fixed.o c++ -Wall -Werror -Wextra -std=c++98 obj/main.o obj/Fixed.o -o ex01 /usr/bin/ld : obj/main.o : dans la fonction « main » : main.cpp:(.text+0xab) : référence indéfinie vers « operator<<(std::ostream&, Fixed const&) » /usr/bin/ld : main.cpp:(.text+0xe8) : référence indéfinie vers « operator<<(std::ostream&, Fixed const&) » /usr/bin/ld : main.cpp:(.text+0x125) : référence indéfinie vers « operator<<(std::ostream&, Fixed const&) » /usr/bin/ld : main.cpp:(.text+0x162) : référence indéfinie vers « operator<<(std::ostream&, Fixed const&) » collect2: error: ld returned 1 exit status make: *** [Makefile:28 : ex01] Erreur 1
- Assistant
L'erreur que vous obtenez vient du fait que vous avez déclaré la surcharge de l'opérateur
<<dansFixed.hpp, mais vous n'avez pas défini l'opérateur dans votre fichier sourceFixed.cpp. Lorsque le linker cherche à obtenir la définition de la fonctionoperator<<(std::ostream&, Fixed const&)appelée dans lemain.cpp, il ne la trouve pas et signale une erreur de "référence indéfinie" (undefined reference).
Étapes pour corriger le problème
-
Déclarez correctement l’opérateur
<<dansFixed.hpp(ce que vous avez déjà fait) : Assurez-vous que cette ligne est bien présente dansFixed.hpp:friend std::ostream& operator<<(std::ostream& out, const Fixed& value);Ce prototype indique que
operator<<est une fonction externe à la classeFixed, mais elle peut accéder aux membres privés et protégés deFixedgrâce à l'amitié (friend).
-
Définissez l’opérateur
<<dansFixed.cpp: Ajoutez cette implémentation dans votre fichierFixed.cpp. Elle permettra d'afficher la représentation en virgule flottante de votre objetFixed.#include "Fixed.hpp" std::ostream& operator<<(std::ostream& out, const Fixed& value) { out << value.toFloat(); // Conversion en flottant avant affichage return out; // Permet d'enchaîner des opérateurs << }
-
Pourquoi cette erreur s'est produite ? L'erreur se produit parce que :
- Vous avez utilisé
std::cout << fixedObjectdans votremainsans avoir défini comment votre classeFixeddoit être affichée. - Le linker cherche alors une définition valide pour
operator<<(std::ostream&, Fixed const&)et ne la trouve pas dans les fichiers compilés (Fixed.oetmain.o).
- Vous avez utilisé
-
Relancez la compilation après avoir ajouté l'opérateur
Une fois que vous avez ajouté la définition dans
Fixed.cpp, relancez votre compilation avecmake:make clean make ./ex01Si tout est correctement configuré, l'exécution du binaire corrigé (
ex01) montrera maintenant le comportement attendu.
Résultat attendu avec un
main.cppcomme le vôtreAvec un code similaire à :
Fixed a; Fixed const b(10); Fixed const c(42.42f); Fixed const d(b); a = Fixed(1234.4321f); std::cout << "a is " << a << std::endl; std::cout << "b is " << b << std::endl; std::cout << "c is " << c << std::endl; std::cout << "d is " << d << std::endl;Vous devriez voir apparaître dans le terminal quelque chose comme ceci lors de l'exécution :
Default constructor called Int constructor called Float constructor called Copy constructor called Float constructor called Copy assignment operator called Destructor called a is 1234.43 b is 10 c is 42.4219 d is 10 Destructor called Destructor called Destructor called Destructor called
Bonus : Vérifiez votre Makefile
Assurez-vous que votre Makefile compense bien tous les fichiers
.cppnécessaires. Voici un exemple basique pour votre projet :NAME = ex01 CXX = c++ CXXFLAGS = -Wall -Werror -Wextra -std=c++98 SRCS = main.cpp Fixed.cpp OBJS = $(SRCS:.cpp=.o) all: $(NAME) $(NAME): $(OBJS) $(CXX) $(CXXFLAGS) -o $(NAME) $(OBJS) %.o: %.cpp $(CXX) $(CXXFLAGS) -c $< -o $@ clean: rm -f $(OBJS) fclean: clean rm -f $(NAME) re: fclean allRelancez ensuite :
make clean make ./ex01
Résumé
Pour résoudre ce problème :
-
Ajoutez l'implémentation de
operator<<dansFixed.cpp. -
Assurez-vous que cela ressemble à ceci :
std::ostream& operator<<(std::ostream& out, const Fixed& value) { out << value.toFloat(); return out; } -
Compilez à nouveau votre projet avec
make.
Après cette modification, le problème de "référence indéfinie" sera résolu, et votre programme devrait fonctionner correctement. 😊
-
- User
┌──(overlord㉿Overlord)-[~/Bureau/cpp02/ex01] └─$ make re rm -f obj/main.o obj/Fixed.o rm -rf obj rm -f ex01 mkdir -p obj/ c++ -Wall -Werror -Wextra -std=c++98 -c main.cpp -o obj/main.o In file included from main.cpp:2: Fixed.hpp:57:31: error: ‘std::ostream& Fixed::operator<<(std::ostream&, const Fixed&)’ must have exactly one argument 57 | std::ostream& operator<<(std::ostream& out, const Fixed& value) | ^~~~~~~~ make: *** [Makefile:25 : obj/main.o] Erreur 1
┌──(overlord㉿Overlord)-[~/Bureau/cpp02/ex01] └─$ et voila le .hpp #ifndef FIXED_HPP #define FIXED_HPP
include
include
include
class Fixed { private: int Integer; static const int IntegerStatic = 8; public: //constructeur par defaut Fixed() : Integer(0) { std::cout << "Default constructor called" << std::endl; } //constructeur de copie Fixed(const Fixed &autre) : Integer(autre.Integer) { std::cout << "Copy constructor called" << std::endl; getRawBits(); } //constructeur qui prend un int et qui le passe en virgule fixe Fixed(int number) { std::cout << "Int constructor called" << std::endl; this->Integer = number << IntegerStatic; // Conversion en virgule fixe (8 bits pour la partie fractionnaire) } //constructeur qui prend un int et qui le passe en virgule fixe Fixed(float number) { std::cout << "Int constructor called" << std::endl; this->Integer = static_cast(number) <<IntegerStatic; // Conversion en virgule fixe (8 bits pour la partie fractionnaire) } //surcharge Fixed& operator=(const Fixed& autre) { if (this != &autre) { Integer = autre.Integer; } std::cout << "Copy assignment operator called" << std::endl; return *this; } //destructeur ~Fixed() { std::cout << "Destructor called" << std::endl; } int getRawBits( void ) const; void setRawBits( int const raw ); float toFloat(void) const; int toInt(void) const; std::ostream& operator<<(std::ostream& out, const Fixed& value) { out << value.toFloat(); // Conversion en flottant avant affichage return out; // Permet d'enchaîner des opérateurs << } friend std::ostream& operator<<(std::ostream& out, const Fixed& value); };
#endif
- Assistant
Le problème vient de la manière dont le surcharge de l'opérateur
<<a été déclaré et défini dans votre classe.Voyons pourquoi cela ne fonctionne pas et ce que vous devez corriger.
Erreur identifiée :
Voici l'erreur indiquée dans votre terminal :
error: ‘std::ostream& Fixed::operator<<(std::ostream&, const Fixed&)’ must have exactly one argumentLa cause :
-
std::ostream& Fixed::operator<<(std::ostream&, const Fixed&):- Cette surcharge ne peut pas être une méthode membre de la classe
Fixed. - Pourquoi ? Parce que l'opérateur d'insertion (
<<) a besoin d'un premier paramètre qui est l'objetstd::ostream(souventstd::cout), et cet argument n'est pas la classeFixedelle-même. - Or, en déclarant cette fonction comme une méthode membre (à l'intérieur de votre classe), le compilateur considère que son premier paramètre implicite est le pointeur
Fixed*(l'instance sur laquelle la méthode est appelée). Cela rend impossible l'utilisation correcte de cet opérateur.
- Cette surcharge ne peut pas être une méthode membre de la classe
-
Une surcharge d'opérateur binaire comme
<<doit généralement être une fonction externe.- Pour accéder aux membres et fonctions privés/protégés de la classe ‘Fixed’ tout en restant externe, elle doit être déclarée en tant que fonction
friend.
- Pour accéder aux membres et fonctions privés/protégés de la classe ‘Fixed’ tout en restant externe, elle doit être déclarée en tant que fonction
Solution principale : Déplacer la surcharge
<<EN DEHORS de la classeFixedCorrigeons cela en procédant par étapes :
Étape 1 : Fichier
Fixed.hppConservez uniquement une déclaration de la fonction
operator<<dansFixed.hppcomme suit :friend std::ostream& operator<<(std::ostream& out, const Fixed& value);La déclaration
friendpermet à cette fonction externe d'accéder aux membres privés/protégés de la classeFixed.Supprimez cette partie erronée dans votre
.hpp:std::ostream& operator<<(std::ostream& out, const Fixed& value);Ainsi, votre classe devient :
#ifndef FIXED_HPP #define FIXED_HPP # include <iostream> # include <string> class Fixed { private: int Integer; // Valeur en virgule fixe static const int IntegerStatic = 8; public: // Constructeurs Fixed(); Fixed(const Fixed &autre); Fixed(int number); Fixed(float number); ~Fixed(); // Surcharge d'opérateur Fixed& operator=(const Fixed& autre); // Méthodes int getRawBits(void) const; void setRawBits(int const raw); float toFloat(void) const; int toInt(void) const; // Déclaration de la fonction friend friend std::ostream& operator<<(std::ostream& out, const Fixed& value); }; #endif
Étape 2 : Fichier
Fixed.cppImplémentez la fonction
operator<<dansFixed.cppcomme une fonction externe (en dehors de la classe).Ajoutez ceci à votre fichier
Fixed.cpp:std::ostream& operator<<(std::ostream& out, const Fixed& value) { out << value.toFloat(); // Appelle la méthode toFloat() pour afficher une représentation flottante return out; // Retourne le flux pour permettre les chaînes d'affichage }Cela garantit que votre opérateur
<<fonctionnera correctement et affichera la valeur en tant que nombre à virgule flottante.
Résumé des modifications faites :
- Votre déclaration dans
Fixed.hppdevient simplement une fonction amie (friend) au lieu d'une méthode membre. - La définition de l'opérateur
<<est déplacée dansFixed.cppen tant que fonction externe.
Exemple d’un code complet et fonctionnel :
Fixed.hpp#ifndef FIXED_HPP #define FIXED_HPP # include <iostream> # include <string> class Fixed { private: int Integer; // Stockage en virgule fixe static const int IntegerStatic = 8; public: // Constructeurs Fixed(); Fixed(const Fixed &autre); Fixed(int number); Fixed(float number); ~Fixed(); // Surcharge d'opérateur Fixed& operator=(const Fixed& autre); // Méthodes d'accès et conversion int getRawBits(void) const; void setRawBits(int const raw); float toFloat(void) const; int toInt(void) const; // Opérateur externe (amie) friend std::ostream& operator<<(std::ostream& out, const Fixed& value); }; #endifFixed.cpp#include "Fixed.hpp" // Constructeurs Fixed::Fixed() : Integer(0) { std::cout << "Default constructor called" << std::endl; } Fixed::Fixed(const Fixed &autre) : Integer(autre.Integer) { std::cout << "Copy constructor called" << std::endl; } Fixed::Fixed(int number) { std::cout << "Int constructor called" << std::endl; this->Integer = number << IntegerStatic; } Fixed::Fixed(float number) { std::cout << "Float constructor called" << std::endl; this->Integer = static_cast<int>(roundf(number * (1 << IntegerStatic))); } // Destructeur Fixed::~Fixed() { std::cout << "Destructor called" << std::endl; } // Surcharge d'opérateur d'affectation Fixed& Fixed::operator=(const Fixed& autre) { std::cout << "Copy assignment operator called" << std::endl; if (this != &autre) { this->Integer = autre.Integer; } return *this; } // Méthodes int Fixed::getRawBits(void) const { return this->Integer; } void Fixed::setRawBits(int const raw) { this->Integer = raw; } float Fixed::toFloat(void) const { return static_cast<float>(this->Integer) / (1 << IntegerStatic); } int Fixed::toInt(void) const { return this->Integer >> IntegerStatic; } // Implémentation de la surcharge de l'opérateur << std::ostream& operator<<(std::ostream& out, const Fixed& value) { out << value.toFloat(); return out; }
Résultat attendu dans le terminal :
Après avoir corrigé les erreurs et relancé la compilation avec
make(oumake re), votre programme devrait fonctionner correctement.Exécution de ce code :
int main() { Fixed a; Fixed const b(10); Fixed const c(42.42f); Fixed const d(b); a = Fixed(1234.4321f); std::cout << "a is " << a << std::endl; std::cout << "b is " << b << std::endl; std::cout << "c is " << c << std::endl; std::cout << "d is " << d << std::endl; return 0; }Affichage attendu dans le terminal :
Default constructor called Int constructor called Float constructor called Copy constructor called Float constructor called Copy assignment operator called Destructor called a is 1234.43 b is 10 c is 42.4219 d is 10 Destructor called Destructor called Destructor called Destructor called
Si vous rencontrez encore des soucis ou si vous avez besoin d'aide supplémentaire (par exemple pour le Makefile), n'hésitez pas ! 😊
-