Class help

[Ch1156]

Ok so i have my class that im making for a game in CryEngine, and i have 2 mechs and each mech is supposed to have its own stats but i cant seem to ge tthem to change, what do i do.

#ifndef CLASSES_H_INCLUDED
#define CLASSES_H_INCLUDED

#include <iostream>
#include <string>

using namespace std;

class BaseMech //This class will be used for enemy and player mechs
{
    public:
        virtual void attack()
        {
            health = 5000;
            Weapon_Damage = 400;
            Ammo = 200;


            cout << health << endl;
            cout << Weapon_Damage << endl;
            cout << Ammo << endl;
        }

    private:
        size_t health; //How much health the mech has
        size_t Weapon_Damage; //How much damage each bullet does
        size_t Ammo; //How many missiles does the mech have
};


class WorldDestroyer: public BaseMech //All classes now inherit functions in ENEMY class
{
    public:
        void attack()
        {
            cout << "\n";

            health = 10000;
            Weapon_Damage = 600;
            Ammo = 40000;

            cout << health << endl;
            cout << Weapon_Damage << endl;
            cout << Ammo << endl;
        }
};


class Pulverizer: public BaseMech
{
    public:
        void attack()
        {
            cout << "\n";

            health = 6000;
            Weapon_Damage = 200;
            Ammo = 4000;

            cout << health << endl;
            cout << Weapon_Damage << endl;
            cout << Ammo << endl;
        }
};

#endif // CLASSES_H_INCLUDED 

[JLBorges]

Use the protected access specifier for members that are to be accessed from derived classes.

class BaseMech //This class will be used for enemy and player mechs
{
    
    // ... 
    
    /* private: */ protected: 
        size_t health; //How much health the mech has
        size_t Weapon_Damage; //How much damage each bullet does
        size_t Ammo; //How many missiles does the mech have
};

[Ch1156]

Ok i changed it to private and i get these errors

obj\Debug\main.o||In function `WorldDestroyer':|
virtual and inline\Classes.h|34|undefined reference to `BaseMech::BaseMech()'|
obj\Debug\main.o||In function `~WorldDestroyer':|
virtual and inline\Classes.h|34|undefined reference to `BaseMech::~BaseMech()'|
obj\Debug\main.o||In function `Pulverizer':|
virtual and inline\Classes.h|52|undefined reference to `BaseMech::BaseMech()'|
obj\Debug\main.o||In function `~Pulverizer':|
virtual and inline\Classes.h|52|undefined reference to `BaseMech::~BaseMech()'|
||=== Build finished: 4 errors, 0 warnings ===|

[Ch1156]

Never mind i dont know why but commenting out

//BaseMech();
//~BaseMech();

made it work.

[bandicoot360]

You don't need the default constructor, the compiler will implicitly define it for you, but you should have:
virtual ~BaseMech() { }
in your BaseMech class

[Ch1156]

Ok this is my first attempt at polymorphism am i doing this ok? The virtual function will have something in them and the functions in each mech class will do something too.

Main.cpp

#include <iostream>
#include <string>
#include "Classes.h"

using namespace std;



int main()
#include <iostream>
#include <string>
#include "Classes.h"

using namespace std;

int main()
{
    WorldDestroyer WDO;
    Pulverizer PO;
    Ravager RO;

    BaseMech *worlddestroyer = &WDO;
    BaseMech *pulverizer = &PO;
    BaseMech *ravager = &RO;

    worlddestroyer->Weap_One();
    worlddestroyer->Weap_Two();
    worlddestroyer->Weap_One_Ammo();
    worlddestroyer->Weap_Two_Ammo();
    worlddestroyer->Mech_Health();

    delete worlddestroyer;
}

Classes.h

#ifndef CLASSES_H_INCLUDED
#define CLASSES_H_INCLUDED

#include <iostream>
#include <string>

using namespace std;

typedef unsigned long long Super;

class BaseMech //This class will be used for enemy and player mechs
{
    public:
        //Basic Mech functions, called when no other functions
        //exist.
        virtual int Weap_One()
        {

        }
        virtual int Weap_Two()
        {

        }
        virtual int Weap_One_Ammo()
        {

        }
        virtual int Weap_Two_Ammo()
        {

        }
        virtual int Mech_Health()
        {

        }


    protected:
        Super Health; //How much health the mech has
        size_t Weapon_One_Damage; //How much damage each bullet does
        size_t Weapon_Two_Damage;
        size_t Weapon_One_Ammo_Count; //How many missiles does the mech have
        size_t Weapon_Two_Ammo_Count;
};

//Bosses

//Boss one

class Ravager: public BaseMech
{
    public:
        int Weap_One()
        {
            Weapon_One_Damage = 600;
            cout << Weapon_One_Damage << endl;
            return Weapon_One_Damage;
        }
        int Weap_Two()
        {
            Weapon_Two_Damage = 450;
            cout << Weapon_Two_Damage << endl;
            return Weapon_Two_Damage;
        }
        int Weap_One_Ammo()
        {
            Weapon_One_Ammo_Count = 600;
            cout << Weapon_One_Ammo_Count << endl;
            return Weapon_One_Ammo_Count;
        }
        int Weap_Two_Ammo()
        {
            Weapon_Two_Ammo_Count = 700;
            cout << Weapon_Two_Ammo_Count << endl;
            return Weapon_Two_Ammo_Count;
        }
        int Mech_Health()
        {
            Health = 10000;
            cout << Health << endl;
            return Health;
        }
};


//Final Boss
class WorldDestroyer: public BaseMech //All classes now inherit functions in ENEMY class
{
    public:
        int Weap_One()
        {
            Weapon_One_Damage = 900;
            cout << Weapon_One_Damage << endl;
            return Weapon_One_Damage;
        }
        int Weap_Two()
        {
            Weapon_Two_Damage = 900;
            cout << Weapon_Two_Damage << endl;
            return Weapon_Two_Damage;
        }
        int Weap_One_Ammo()
        {
            Weapon_One_Ammo_Count = 5000;
            cout << Weapon_One_Ammo_Count << endl;
            return Weapon_One_Ammo_Count;
        }
        int Weap_Two_Ammo()
        {
            Weapon_Two_Ammo_Count = 7000;
            cout << Weapon_Two_Ammo_Count << endl;
            return Weapon_Two_Ammo_Count;
        }
        int Mech_Health()
        {
            Health = 10000000;
            cout << Health << endl;
            return Health;
        }
};


class Pulverizer: public BaseMech
{
    public:
        int Weap_One()
        {
            Weapon_One_Damage = 200;
            cout << Weapon_One_Damage;
            return Weapon_One_Damage;
        }
        int Weap_Two()
        {
            Weapon_Two_Damage = 200;
            cout << Weapon_Two_Damage;
            return Weapon_Two_Damage;
        }
        int Weap_One_Ammo()
        {
            Weapon_One_Ammo_Count = 400;
            cout << Weapon_One_Ammo_Count << endl;
            return Weapon_One_Ammo_Count;
        }
        int Weap_Two_Ammo()
        {
            Weapon_Two_Ammo_Count = 300;
            cout << Weapon_Two_Ammo_Count << endl;
            return Weapon_Two_Ammo_Count;
        }
        int Mech_Health()
        {
            Health = 4000;
            cout << Health;
            return Health;
        }
};

#endif // CLASSES_H_INCLUDED 

[Ch1156]

bump

[bandicoot360]

that's ok but there are two problems: 1) you still don't have virtual destructor in your base class, that will cause memory leaks. 2) what's the purpose of those data members?!!! I mean why do you assign data members a constant value each call?

That's the way it's done:

class BaseMech {
    public:
        BaseMech(Super h, size_t d1, size_t d2, size_t ammo1, size_t ammo2)
              : Health(h)
              , Weapon_One_Damage(d1)
              , Weapon_Two_Damage(d2)
              , Weapon_One_Ammo_Count(ammo1)
              , Weapon_Two_Ammo_Count(ammo2)
              {}

        virtual int Weap_One() = 0; // BaseMech is an abstract base class, no definition required
        virtual int Weap_Two() = 0;
        virtual int Weap_One_Ammo() = 0;
        virtual int Weap_Two_Ammo() = 0;
        virtual int Mech_Health() = 0

        virtual ~BaseMech() { }
    protected:
        Super Health; //How much health the mech has
        size_t Weapon_One_Damage; //How much damage each bullet does
        size_t Weapon_Two_Damage;
        size_t Weapon_One_Ammo_Count; //How many missiles does the mech have
        size_t Weapon_Two_Ammo_Count;
};

[bandicoot360]

class Ravager: public BaseMech
{
    public:
        explicit Ravager(Super h = 10000, size_t d1 = 600, size_t d2 = 450, size_t ammo1 = 600, size_t ammo2 = 700)
        : BaseMech(h, d1, d2, ammo1, ammo2)
        {  }

        virtual int Weap_One()
        {
            cout << Weapon_One_Damage << endl;
            return Weapon_One_Damage;
        }

        virtual int Weap_Two()
        {
            cout << Weapon_Two_Damage << endl;
            return Weapon_Two_Damage;
        }

        virtual int Weap_One_Ammo()
        {
            cout << Weapon_One_Ammo_Count << endl;
            return Weapon_One_Ammo_Count;
        }

        virtual int Weap_Two_Ammo()
        {
            cout << Weapon_Two_Ammo_Count << endl;
            return Weapon_Two_Ammo_Count;
        }

        virtual int Mech_Health()
        {
            cout << Health << endl;
            return Health;
        }

        virtual ~Ravager() { } // In case you derive another class from Ravager
};

the rest for you

[Ch1156]

ok i have soem questions, what are the pure virtual functions for, and why make all those functions in Ravager virtual instead of ints?

[bandicoot360]

Every class with at least one pure virtual function is an abstract base class(i.e you can not make an instance of that class). Here I believe you are using BaseMech for that purpose so I made it abstract.

The virtuals in ravager are not needed, you can make them int, but what if you later decided to derive another class from ravager and access them through a "BaseMech *" or "Ravager *" ?

[bandicoot360]

I have a suggestion for you, go to sfml-dev.org, see the documentation. Take a look at the Drawable class and the Sprite class, The Sprite class "is a" Drawable. You can view the code online.