La redéfinition de vs de remplacement dans le C++

Je suis confus sur les différences entre les redéfinir et de fonctions de remplacement dans les classes dérivées.

Je sais qu'En C++, de redéfinir les fonctions sont statiquement lié et remplacé fonctions sont dynamiquement lié et qui a une fonction virtuelle est substituée, et non virtuelle la fonction est redéfini.

Lorsqu'une classe dérivée "redéfinit" une méthode dans une classe de base est considérée redéfinir. Mais quand une classe dérivée est virtuel, il n'est plus redéfinit mais plutôt des remplacements. Si je comprends bien, la logistique des règles, mais je ne comprends pas la ligne de fond.

Dans l'exemple ci-dessous, la fonction SetScore est redéfini. Cependant, si je fais le setScore fonction de la classe de base virtuelle (par l'ajout du mot virtuel) le setScore dans la classe dérivée sera remplacée. Je ne comprends pas la ligne de fond - quelle est la différence. dans setScore?

La classe de base:

class GradedActivity
{
protected:
   char letter;            //To hold the letter grade
   double score;           //To hold the numeric score
   void determineGrade();  //Determines the letter grade
public:
   //Default constructor
   GradedActivity()
  { letter = ' '; score = 0.0; }

 //Mutator function
   void setScore(double s) 
      { score = s;
        determineGrade();}

   //Accessor functions
   double getScore() const
      { return score; }

       char getLetterGrade() const
      { return letter; }
};

La classe dérivée:

class CurvedActivity : public GradedActivity
{
protected:
   double rawScore;     //Unadjusted score
   double percentage;   //Curve percentage
public:
   //Default constructor
   CurvedActivity() : GradedActivity()
      { rawScore = 0.0; percentage = 0.0; }

   //Mutator functions
   void setScore(double s) 
      { rawScore = s;
        GradedActivity::setScore(rawScore * percentage); }

   void setPercentage(double c)
      { percentage = c; }

   //Accessor funtions
   double getPercentage() const
      { return percentage; }

   double getRawScore() const
      { return rawScore; }
};

Voici les principaux:

   //Define a CurvedActivity object.
   CurvedActivity exam;

   ... 

   //Send the values to the exam object.
   exam.setPercentage(percentage);
   exam.setScore(numericScore);

Primordial facilite la classe de polymorphisme. La surcharge facilite polymorphisme fonctionnel. La redéfinition de ne et est une erreur.

OriginalL'auteur YelizavetaYR | 2014-11-04

base c++class derived inheritance

17

Voici quelques différences fondamentales:

Un surchargé fonction est une fonction qui partage son nom avec un ou plusieurs autres fonctions, mais qui a un autre paramètre de la liste. Le compilateur choisit la fonction désirée en fonction sur les arguments utilisés.

Un substituée fonction est une méthode dans une classe descendante qui a une définition différente qu'une fonction virtuelle dans une classe ancêtre. Le compilateur choisit la fonction souhaitée en fonction du type de l'objet utilisé pour appeler la fonction.

Un redéfini fonction est une méthode dans une classe descendante qui a une définition différente qu'un non-fonction virtuelle dans une classe ancêtre. Ne pas le faire. Puisque la méthode n'est pas du virtuel, le compilateur choisit la fonction d'appel en se basant sur le type statique de l'objet de référence, plutôt que le type réel de l'objet.
- Vérifier le type statique signifie que la vérification de type se produit au moment de la compilation. Aucune information de type est utilisé lors de l'exécution dans ce cas.
- Dynamique de la vérification de type se produit lorsque le type d'informations est utilisé lors de l'exécution. C++ utilise un mécanisme appelé RTTI (runtime type d'information) à mettre en œuvre. L'exemple le plus commun où RTTI est utilisé est l'opérateur dynamic_cast qui permet de passer de types polymorphes:
Merci, c'est peut être stupide, mais qu'est-ce que cela signifie: type statique de l'objet de référence.
Les fonctions de surcharge si dans le même champ d'application. Peut vouloir ajouter.
"Le compilateur choisit la fonction souhaitée en fonction du type de l'objet utilisé pour appeler la fonction." ce n'est pas correct, le compilateur n'a pas à décider quoi que ce soit. La décision se fait au moment de l'exécution par vtable de recherche.
Si la classe B dérive de la classe A et nous avons Un MyA; et B MyB; et ne MyA=MyB; statique type de MyA est Un, tout en maintenant (dynamiquement) MyA est le stockage d'un B (sa dynamique est de type B). Si nous nous ci ont de la classe C dérivant de B et de C MyC; et ne MyA = MyC, une fois de plus, le type dynamique de MyA changé pour être un C. Le type statique de MyA continue à être un A.

OriginalL'auteur Lawrence Aiello

Vous devez vous connecter pour publier un commentaire.