C++ erreur: objet de la classe abstraite type n'est pas autorisée: fonction virtuelle pure n'a pas d'overrider

Ayant des problèmes avec l'héritage. Je n'ai aucune idée de ce que je fais mal.

FigureGeometry.h

    #ifndef FIGUREGEOMETRY
#define FIGUREGEOMETRY

static const float PI = 3.14159f;

class FigureGeometry
{

public:
    virtual float getArea() const = 0;
    virtual float getPerimeter() const = 0;
};

#endif

Cercle.h

    #ifndef CIRCLE
#define CIRCLE

#include "FigureGeometry.h"

class Circle:public FigureGeometry
{
    float radius;
public:
    Circle(float theRadius)
    {
        radius = theRadius;
    }
    float getRadius() {return radius;}
    float getArea() {return getRadius() * getRadius() * PI;}
    float getPerimeter() {return getRadius() * 2 * PI;}
};

#endif

puis dans main.cpp, sur la ligne contenant "Circle c1(5);" j'obtiens l'erreur:

21  IntelliSense: object of abstract class type "Circle" is not allowed:
            pure virtual function "FigureGeometry::getArea" has no overrider
            pure virtual function "FigureGeometry::getPerimeter" has no overrider   c:\Users\moog\Documents\Visual Studio 2012\Projects\data structures 3\data structures 3\main.cpp    9   9   data structures 3

getArea() et getArea() const sont deux fonctions différentes.

OriginalL'auteur Bacu | 2014-11-09

c++

7

Vos fonctions doivent être:-
```
float getArea() const {return getRadius() * getRadius() * PI;}
float getPerimeter() const {return getRadius() * 2 * PI;}
```
RAISON DE CE COMPORTEMENT :-

Lorsque vous re-définir une fonction dans la classe dérivée avec les mêmes paramètres que dans la classe de base, alors que c'est appelé comme primordial.
Alors que si vous re-définir la fonction avec un paramètre différent alors il serait une tentative d'utilisation de la surcharge de côté. Mais la surcharge est possible que dans un contexte de classe. Donc, dans ce cas correspondants de la classe de base de la fonction serait caché.

Pour l'e.g:- ci-Dessous est vaine tentative sur la surcharge.
```
class Base
{
public:
   virtual void display () const;
};

class Derived 
{
public:
   virtual void display ();
};

int main()
{
    const Derived d;
    d.display();           //Error::no version defined for const....
}
```
De sorte que vous obtenez l'erreur d'affichage dans la dérivée serait de masquer l'affichage de base.

De même votre fonction virtuelle pure serait caché je.e compilateur de traiter ce cas comme il n'y a pas de fonction définie dans le dérivé correspondant à la classe de base de la fonction virtuelle pure.Que ferait la dérivée aussi une classe abstraite.

Espère que les choses sont claires comme le cristal...

La fonction de surcharge est possible en dehors de la portée de classe.
O. K, de sorte que pensez-vous de la raison pour cela peut être?
Le non-const méthode ne modifie pas la const un dans la classe de base (en raison de divergences de const-qualification), mais depuis, il a le même nom de cache, le seul dans la classe de base. Puisqu'il n'est pas surchargé, la classe dérivée devient abstrait.
C'est très bien...Mais qu'est ce que je me demande pourquoi il se cache??? tout simplement parce que de même nom. Je crois que ce qui est des fonctions avec le même nom et une avec const est un bon candidat pour la surcharge...N'est-ce pas???
S'il vous plaît essayer de compiler l'exemple ci-dessus...il doit compiler correctement avaient une surcharge dans la classe des étendues été autorisé...et merci de me donner bonne raison pourquoi il n'est pas de la compilation

OriginalL'auteur ravi
0

Votre getArea() et getPerimeter() méthodes ne remplacent pas les méthodes virtuelles déclaré dans FigureGeometry car ils ne correspondent pas dans const-qualification. Donc Circle devient abstraite, puisque ces méthodes sont virtuelles pures; et vous ne pouvez pas créer des objets de type abstrait.

Pour corriger cela, il suffit d'ajouter const à la fois de vos méthodes. Aussi, assurez-vous d'avoir correctement surdéfini méthodes de la classe de base, utilisez la override rédacteur de devis:
```
float getArea() const override;
float getPerimeter() const override;
```
Si ils ne remplacent pas le compilateur vous permettra de savoir avec un message d'erreur.

OriginalL'auteur 0x499602D2
0

Vous avez oublié de placer qualificatif const pour ces fonctions virtuelles dans la classe dérivée. Écrire
```
float getArea() const {return getRadius() * getRadius() * PI;}
float getPerimeter() const {return getRadius() * 2 * PI;}
```
Donc, en fait, dans la classe dérivée, vous avez déclaré de nouvelles fonctions qui cachent des fonctions virtuelles de la classe de base avec le même nom.

Aussi, vous devez déclarer le destructeur également que virtuel. Par exemple
```
class FigureGeometry
{
public:
    //...
    virtual ~FigureGeometry() = default;
};
```
Ou
```
class FigureGeometry
{
public:
    //...
    virtual ~FigureGeometry() {}
};
```
OriginalL'auteur Vlad from Moscow

Vous devez vous connecter pour publier un commentaire.