I am attempting to implement an interface in C++ for a game that I am writing and I am running in an error.
Here is the interface and its subclass that I created:
//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;
}
};
Here is the subclass :
/*
* 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;
}
};
The error being returned from the compiler is : The type 'Attack' must implement the inherited pure virtual method 'Attack::calculate_damage'
Does anyone know the correct syntax for this? Do I have the inheritance setup correctly?
The const
in your derrived class makes your derrived class's method's signature different from the virtual method in the base class. As far as the compiler is concerned you've overloaded calculate_damage in the Normal
class, giving it a const
and non-const
version.
You are probably looking for
Normal(std::string name)
: Attack(name,NORMAL)
{}
That calls the base constructor, as you probably intended. The code as it is now creates a temporary unnamed variable of type Attack
, which is an abstract class and its what triggers the error.
Also, the base function calculate_damage
is not const
.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With