Troubles overriding a const in a derived class

I have a Base class and a Derived class, only the parts of the class in question are listed for brevity:

Code:

---

class Base
        {
public:
        static const int type;

        Base (int x=0, int y=0);
        ~Base();
              };

class Derived : public Base
              {
public:
        static const int type;

        Derived (int x=0, int y=0);
        ~Derived();
              };

const int Base::type = 0;
const int Derived::type = 1;

Base::Base (int x, int y)
                {
                cerr << "You created an object of type " << type;
                }
Base::~Base()
                {
                cerr << "Destructor called for object of type " << type;
                }

Derived::Derived (int x, int y) : Base (x, y)
                {} 

Derived::~Derived()
                {}

---

Now in my code I declare an array of pointers which will be used to point to objects of either the Base or Derived Classes:

Code:

---

Base *ClassPointers[2];

ClassPointers[0] = new Base();
ClassPointers[1] = new Derived();

---

Now if I look in my error log, I see these messages:

Quote:

---

You created an object of type 0
You created an object of type 0

---

Of course, I expect the messages to look like this:

Quote:

---

You created an object of type 0
You created on object of type 1

---

What gives? Help would be greatly appreciated.

I think it's because the derived class calls the base constuctor which you use Base::type in. It will always be Base::type whenever that constructor is called not Derived::type like you want it to be.

Code:

---

Base::Base (int x, int y)
{
    cerr << "You created an object of type " << type;  // type refers to Base::type
}

---

So how can I solve this problem? The Base class' constructor is always called after the Derived class' constructor when a Derived class is instantiated, right? And just because the constructor for Base reports 0 for type, does that mean Derived::type is actually equal to 0 or is it equal to 1? I need this variable for my program to identify what derivative of the class it is (I'm actually going to rewrite Base as a pure virtual class and only instantiate derived classes) Or can you think of a better way for me to achieve this?

Hi

Just use a virtual method.

e.g.
class Base {
....
virtual int GetInstanceType();
....

override it in every descendant of the Base class and
avoid invoking any virtual methods in the constructors and all be ok.

You can make this method abstract(pure virtual by adding =0 in the method declaration) in order to force the users of the Base class to implement it.

damyan

Quote:

---

Originally posted by damyan
Just use a virtual method.

e.g.
class Base {
....
virtual int GetInstanceType();
....

override it in every descendant of the Base class and
avoid invoking any virtual methods in the constructors and all be ok.

---

I did try this and I don't like the way it works. It does work if I don't call the GetInstanceType() parameter in the constructor, but the problem is that I do need to know what type the instance is inside the base constructor. For instance, for error logging purposes I have the following line in the base constructor (and yes I had to un-pure-virtualize the GetInstanceType function to make this work):

Write_Error("\nCreated instance of type %i", bob[GetInstanceType()]");

And it always states in the error log that an instance of type 0 was created. To have to delete this line from the constructor and re-write it in every derived class would be a real pain. I mean, isn't this what deriving classes is for? Convenience and reduction of code duplication? Is there any way to solve this problem? If not, can you tell me exactly why this happens so I can at least understand why it does not work?

It happens because you are declaring TWO variables named type, one in the parent class, one in the derived. It IS legal C++ to do this, although it's not a good idea.

In this case, when you are inside the parent class's constructor, the parent only "sees" the variables that are part of its class -- so it sees only the parent's copy of type.

I don't believe you CAN know, when you are in a parent's constructor, if you are in the base or derived class.