IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

Classe abstraite et opérateurs surchargés utilisant des méthodes abstraites


Sujet :

C++

  1. #1
    Membre émérite
    Avatar de VivienD
    Homme Profil pro
    Développeur logiciel
    Inscrit en
    Octobre 2009
    Messages
    523
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : Allemagne

    Informations professionnelles :
    Activité : Développeur logiciel
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Octobre 2009
    Messages : 523
    Points : 2 278
    Points
    2 278
    Par défaut Classe abstraite et opérateurs surchargés utilisant des méthodes abstraites
    Bonsoir,

    Je suis en train de créer une bibliothèque personnelle pour travailler avec la logique floue et la régulation au travers de cette logique. J'ai créé une classe abstraite pour gérer les ports (entrées et sorties) pour les grandeurs physiques et ceux pour les valeurs logiques. Voici le code de l'en-tête et le code source:
    Code abstractport.h : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    #ifndef ABSTRACTPORT_H
    #define ABSTRACTPORT_H
     
    class AbstractPort
    {
        //Public members
        public:
            //Enumeration
            enum Type
            {
                Unknown, Fuzzy, Physical
            };
     
            //Constructors
            AbstractPort();
            AbstractPort(const Type& type, const double& value);
            AbstractPort(const AbstractPort& other);
     
            //Destructor
            ~AbstractPort();
     
            //Getters
            double value() const;
            Type type() const;
     
            //Setter
            void setValue(const double& newVal);
     
            //Overloaded assignment operator
            AbstractPort operator=(const AbstractPort& other);
     
            //Overloaded relational operators
            bool operator==(const AbstractPort& other) const;
            bool operator!=(const AbstractPort& other) const;
     
        //Private members
        private:
            //Data fields
            Type m_type;
            double m_value;
     
        //Protected members
        protected:
            //Protected setter
            void setType(const Type& type);
     
            //Methods to reimplement
            virtual void furtherAssignment(const AbstractPort& other) = 0;
            virtual bool furtherConditionAboutNewValue(double newValue) const = 0;
            virtual bool furtherEqualityTest(const AbstractPort& other) const = 0;
    };
     
    #endif // ABSTRACTPORT_H
    Code abstractport.cpp : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    #include "abstractport.h"
     
    AbstractPort::AbstractPort() :
        m_type  (AbstractPort::Unknown) ,
        m_value (0.0f)
    {
     
    }
     
    AbstractPort::AbstractPort(const AbstractPort::Type& type, const double& value) :
        m_type  (type) ,
        m_value (value)
    {
     
    }
     
    AbstractPort::AbstractPort(const AbstractPort& other) :
        m_type  (other.type()) ,
        m_value (other.value())
    {
     
    }
     
    AbstractPort::~AbstractPort()
    {
     
    }
     
    AbstractPort::Type AbstractPort::type() const
    {
        return this->m_type;
    }
     
    double AbstractPort::value() const
    {
        return this->m_value;
    }
     
    void AbstractPort::setValue(const double& newVal)
    {
        if(furtherConditionAboutNewValue(newVal) && (newVal != m_value))
        {
            m_value = newVal;
        }
    }
     
    AbstractPort AbstractPort::operator=(const AbstractPort& other)
    {
        if(*this == other)
        {
            this->m_type = other.type();
            this->m_value = other.value();
            furtherAssignment(other);
        }
        return *this;
    }
     
    bool AbstractPort::operator==(const AbstractPort& other) const
    {
        return ((this->m_type == other.type()) && (this->m_value == other.value()) && furtherEqualityTest(other));
    }
     
    bool AbstractPort::operator!=(const AbstractPort& other) const
    {
        return !(*this == other);
    }
     
    void AbstractPort::setType(const AbstractPort::Type& type)
    {
        m_type = type;
    }
    Cependant, il y a un problème. Mon compilateur, MinGW, me renvoie des erreurs sur l'opérateur = que j'ai surchargé. Voici les erreurs:
    • Type de retour non-valide car abstrait (dans le fichier d'en-tête et le fichier source);
    • Allocation impossible d'un objet d'une classe abstraite (seulement dans le fichier source).

    Honnêtement, je ne vois pas comment corriger ce problème; c'est pourquoi je demande votre aide.

    Merci d'avance.

    Adishatz!
    De retour, plus sportif mais toujours aussi moche.
    _____________
    Pro: Programmation en C/C++ (embarqué ou non)
    Loisir: Programmation en C++11/14/17 avec la STL ou Qt 5

  2. #2
    Expert confirmé

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2007
    Messages
    1 895
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Septembre 2007
    Messages : 1 895
    Points : 4 551
    Points
    4 551
    Par défaut
    Le prototype canonique de l'opérateur = est le suivant :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    Type& Type::operator=(const Type& other)
    En fait, ton code renvoie un objet du type AbstractPort - et cet objet est une instance d'une classe abstraite. Il faut que tu renvoie une référence sur un tel objet.

    Ceci dit, operator= et classe abstraite ne font pas forcément bon ménage...
    [FAQ des forums][FAQ Développement 2D, 3D et Jeux][Si vous ne savez pas ou vous en êtes...]
    Essayez d'écrire clairement (c'est à dire avec des mots français complets). SMS est votre ennemi.
    Evitez les arguments inutiles - DirectMachin vs. OpenTruc ou G++ vs. Café. C'est dépassé tout ça.
    Et si vous êtes sages, vous aurez peut être vous aussi la chance de passer à la télé. Ou pas.

    Ce site contient un forum d'entraide gratuit. Il ne s'use que si l'on ne s'en sert pas.

  3. #3
    Membre émérite
    Avatar de VivienD
    Homme Profil pro
    Développeur logiciel
    Inscrit en
    Octobre 2009
    Messages
    523
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : Allemagne

    Informations professionnelles :
    Activité : Développeur logiciel
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Octobre 2009
    Messages : 523
    Points : 2 278
    Points
    2 278
    Par défaut
    Merci de ton aide.

    Citation Envoyé par Emmanuel Deloget Voir le message
    [...]
    Ceci dit, operator= et classe abstraite ne font pas forcément bon ménage...
    Donc, je ferais mieux d'implémenter cet opérateur dans les classes-filles (qui ne seront pas abstraites) plutôt que dans cette classe; c'est ça?

    PS: Je n'oublie pas la pastille.
    De retour, plus sportif mais toujours aussi moche.
    _____________
    Pro: Programmation en C/C++ (embarqué ou non)
    Loisir: Programmation en C++11/14/17 avec la STL ou Qt 5

  4. #4
    Expert confirmé

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2007
    Messages
    1 895
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Septembre 2007
    Messages : 1 895
    Points : 4 551
    Points
    4 551
    Par défaut
    Citation Envoyé par VivienD Voir le message
    Merci de ton aide.


    Donc, je ferais mieux d'implémenter cet opérateur dans les classes-filles (qui ne seront pas abstraites) plutôt que dans cette classe; c'est ça?

    PS: Je n'oublie pas la pastille.
    Non

    L'opérateur = est généralement réservé aux types qui se comportent comme des valeurs. Ces types font de très mauvais candidats pour une hiérarchie de classes (on a plus tendance à les composer).

    La notion de classe dérivée est liée à des objet ayant une tout autre sémantique (sémantique d'entité), et les entités s'accommodent mal d'un opérateur = (pour la simple et bonne raison qu'il n'y a aucune logique à changer l'identité d'une entité).

    cf. (désolé pour le shameless plug) cet article sur mon blog (qui renvoie, à la fin, à la FAQ de dvp.com)
    [FAQ des forums][FAQ Développement 2D, 3D et Jeux][Si vous ne savez pas ou vous en êtes...]
    Essayez d'écrire clairement (c'est à dire avec des mots français complets). SMS est votre ennemi.
    Evitez les arguments inutiles - DirectMachin vs. OpenTruc ou G++ vs. Café. C'est dépassé tout ça.
    Et si vous êtes sages, vous aurez peut être vous aussi la chance de passer à la télé. Ou pas.

    Ce site contient un forum d'entraide gratuit. Il ne s'use que si l'on ne s'en sert pas.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 14
    Dernier message: 08/04/2008, 17h42
  2. Réponses: 5
    Dernier message: 25/03/2008, 12h31
  3. Classe générique pour simplifier l'utilisation des fichiers
    Par Oprichnik dans le forum Contribuez / Téléchargez Sources et Outils
    Réponses: 10
    Dernier message: 10/08/2007, 00h15
  4. Utilisation des méthodes de classe dans une autre classe
    Par ChriGoLioNaDor dans le forum C++
    Réponses: 4
    Dernier message: 28/07/2007, 16h10
  5. Réponses: 1
    Dernier message: 09/03/2006, 19h15

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo