Penso di aver scavalcato un metodo virtuale ma sto ancora ottenendo: "X deve implementare il metodo virtuale puro ereditato Y"

Question

Sto tentando di implementare un'interfaccia in C++ per un gioco che sto scrivendo e sto eseguendo in un errore.

Ecco l'interfaccia e la sua sottoclasse che ho creato:

//Attack.h 
//defines a set of values associated with all attacks 
//and an interface for all attacks 
typedef unsigned const int attack_type; 
typedef unsigned const int p_attack_type; 
//defines the attack types 
static const attack_type NORMAL = 0; 
static const attack_type ADDER = 1; 
static const attack_type MULTIPLIER = 2; 
static const attack_type AREA_OF_EFFECT = 3; 
static const attack_type DAMAGE_OVER_TIME = 4; 
static const attack_type STATUS = 5; 

//String representation of the names of attack types 
static std::string attack_types [] = {"Normal","Adder","Multiplier","Area-Of-Effect","Damage-Over-Time","Status"}; 

class Attack 
{ 
    protected: 
     std::string attack_name;//the name of this attack 
     attack_type type;//the type of attack this represents 
     int cool_down_turns;//represents the number of turns this ability cannot be used after being used 
     bool causesGlobalCooldown;//does this attack cause ALL abilities to cooldown -- during combat should force cooldown on everything 
     bool on_cool_down; 

    public: 
     Attack(std::string name, attack_type, int cooldown_t, bool causesGlobalCooldown = false) 
     { 
      this->attack_name = name; 
      this->type = attack_type; 
      this->causesGlobalCooldown = causesGlobalCooldown;//whether or not ALL abilities need to cooldown 
      this->cool_down_turns = cooldown_t;//amount of turns that cooldown occurs 
      this->on_cool_down = false;//whether or not this attack is on cooldown 
     } 

     //the main method called to perform this attack 
     //calculate damage, calculate cooldown -- for spells calculate cost 
     //return the amount of damage this attack does 
     virtual int do_attack(int modifier, int roll) 
     { 
      //calculate damage 
      int damage = calculate_damage(modifier,roll); 
      //check cooldown 
      if(this->cool_down_turns>0) 
      { 
       this->cooldown(true); 
      } 
      return damage; 
     } 

     //defined by sub classes -- useful to tell you how much damage the attack is going to do 
     virtual int calculate_damage(int modifier, int roll) = 0; 

     //**standard method definitions**// 

     //get the attack name 
     std::string get_attack_name() const 
     { 
      return this->attack_name; 
     } 

     //get the attack type 
     attack_type get_attack_type() const 
     { 
      return this->type; 
     } 

     //get the attack type name of this attack 
     std::string get_attack_type_name() const 
     { 
      return attack_types[this->type]; 
     } 

     //check the cooldown status of this attack 
     bool cooldown() const 
     { 
      return on_cool_down; 
     } 

     //set the cooldown status of this attack 
     void cooldown(bool set) 
     { 
      this->on_cool_down = set; 
     } 


}; 

Ecco la sottoclasse:

/* 
* Normal.cpp 
* 
* Created on: Jul 15, 2012 
*  Author: christian 
*  Standard Definition of a Normal attack 
*/ 
#include "Attack.h" 

class Normal : public Attack 
{ 
    public: 

     Normal(std::string name) 
     { 
      Attack(name,NORMAL); 
     } 

     int calculate_damage(int modifier, int roll) const 
     { 
      return roll + modifier; 
     } 
}; 

L'errore viene restituito dal compilatore è: Il tipo di 'attacco' must implementare il metodo virtuale puro ereditato 'Attack :: calculate_damage'

Qualcuno conosce la sintassi corretta per questo? Ho impostato correttamente l'ereditarietà?

Answer 1

Il const nella classe derrived rende la firma del metodo della propria classe derrivata diversa dal metodo virtuale nella classe base. Per quanto riguarda il compilatore, è necessario sovraccaricare calculate_damage nella classe Normal, assegnandogli una versione const e non-const.

Answer 2

Probabilmente si sta cercando

Normal(std::string name) 
    : Attack(name,NORMAL) 
{} 

che chiama il costruttore di base, come probabilmente desiderato. Il codice così com'è ora crea una variabile anonima temporanea di tipo Attack, che è una classe astratta e il suo che attiva l'errore.

Inoltre, la funzione di base calculate_damage non è const.