CODEWITHSUNDEEP
c++polymorphismvirtual
Nicholas Hamilton
Nicholas Hamilton

Reputation: 10506

C++ issue with polymorphism base and inherited class instantiation

I have a basic base class and a couple of sub-classes which inherit from it.

Class Base{
public:
   Base(){};
   virtual ~Base();
   virtual void foomethod()=0; //Marked as pure virtual
};

Class A : public Base{
   A(){};  //Ctor
   ~A(){}; //Dtor
   void foomethod(){ /* DO SOMETHING */ }
}
Class B : public Base{
   B(){};  //Ctor
   ~B(){}; //Dtor
   void foomethod(){ /* DO SOMETHING */ }
}

Use of the above is throwing an error in the following usage:

Base a = A();
Base b = B();

The compiler is complaining about the function foomethod() being pure virtual.

However, when the following is used, there is no problem.

A a = A();
B b = B();

I would have thought that the first instance should be accepted due to C++'s principles of polymorphism. I want to enforce a specific method implementation of the method in sub-classes. If it is marked as virtual only, there is not guarantee that it will be explicitly overrided.

Upvotes: 2

Views: 1265

Answers (1)

Marco A.
Marco A.

Reputation: 43662

There are several issues with your code, I'll try to get most of them:

  1. You can't have a pure function without marking it as virtual

  2. You can't create objects of an abstract Base class (there's no code for the methods)

  3. When you write

    Base b = A();

    you're creating two objects and then assigning the A object to the Base b object. This cannot happen since Base is abstract but in cases where this can happen you could experience the slicing problem.

  4. You marked the destructor as virtual in the derived classes but not in the Base (and no definition either), always mark it as virtual when using virtual polymorphism otherwise derived destructors will not be called

This is a more correct way of doing it:

#include <iostream>
using namespace std;

class Base{
public:
   Base(){};
   virtual ~Base() {};
   virtual void foomethod()=0; //Marked as pure virtual
};

class A : public Base{
public: 
   A(){};  //Ctor
   virtual ~A(){}; //Dtor
   void foomethod(){ cout << "Hello from A"; }
};
class B : public Base{
public:
   B(){};  //Ctor
   virtual ~B(){}; //Dtor
   void foomethod(){ /* DO SOMETHING */ }
};

int main() {

    // Base obj; // Can't do that
    Base *obj = new A();
    obj->foomethod(); // A's one
    delete obj;

    return 0;
}

http://ideone.com/gvcL9S

Oh and there were some syntax errors here and there.. and a visibility problem if you intend to use those functions from the outside.. but I believe the excerpt was just a pseudocode one.

Upvotes: 3

Related Questions