Creo que he redefinido un método virtual pero sigo obteniendo: "X debe implementar el método virtual puro heredado Y"

Question

Estoy intentando implementar una interfaz en C++ para un juego que estoy escribiendo y estoy ejecutando en un error

Aquí es la interfaz y su subclase que creé:

//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; 
     } 


}; 

Aquí está la subclase:

/* 
* 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; 
     } 
}; 

El error que se devuelve desde el compilador es: El tipo 'Ataque' must implementar el método virtual puro heredado 'Attack :: calculate_damage'

¿Alguien sabe la sintaxis correcta para esto? ¿Tengo la configuración de herencia correctamente?

Answer 1

El const en su clase de Derrived hace que la firma de su método de clase derived sea diferente del método virtual en la clase base. En lo que respecta al compilador, tiene sobrecargado calculate_damage en la clase Normal, dándole una versión const y non-const.

Answer 2

Usted probablemente está buscando

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

que llama al constructor base, como probablemente pretendía. El código tal como está ahora crea una variable temporal sin nombre de tipo Attack, que es una clase abstracta y es lo que desencadena el error.

Además, la función base calculate_damage no es const.