Question

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?

Answer 1

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.