Calling a virtual function before Implementation - c++

Question

So I have this kind of setup
class Base
{
public:
Base();
virtual void parse() = 0;
};
Base::Base()
{
parse();
}
class Sub : public Base
{
public:
Sub();
void parse();
};
Sub::Sub() : Base() {}
void Sub::parse()
{
// DO stuff
}
I'm wondering if there's anway I can do something similar to this, right now I'm getting an error that says I can't call a pure virtual function which makes sense. Are there any keywords out there that I can use to make this work?
I think making parse() just virtual and not pure virtual would work, but I would like the user to have to overwrite it.

Answer 1

Invoking virtual member functions in a constructor (or destructor) will never make you end up in an overridden version of that function in a derived class.
The reason is that base class constructors (destructors) are executed before (after) derived class' constructors (destructors). That means that the part of an object representing the derived class simply is not yet (not anymore) existing. And calling member functions on non-existing objects isn't possible.
You will need to implement a form of two-phase construction (which isn't built into the language) in order to do what you want. Usually that's done by having a wrapping class first fully construct a Sub object and only then call parse() on it.

Answer 2

The point here is that you can't call pure virtual functions in the constructor, and even if you would provide an implementation, only the Base classes' implementation would be used in the constructor.
The reason is simply that the constructor of Base is executed right at the start of Sub, so any virtual function call to Sub would be called on an incomplete object.
In general, there is no solution for this: You cannot dispatch virtual functions in constructors or destructors.

Answer 3

The resolution of a virtual function cannot find a function in a class
which hasn't been constructed. (Formally: the dynamic type of the
object is that of the constructor or destructor which is running.) So
you need some sort of post-constructor, which the language doesn't
support.
You can sort of work around it by using a dummy parameter, which calls
the function you need in its destructor, e.g.:
class Base
{
public:
class PostConstructor
{
Base* owner;
friend class Base;
public:
PostConstructor() : owner( NULL ) {}
~PostConstructor() { owner->parse(); }
};
Base( PostConstructor const& helper )
{
helper.owner = this;
}
};
class Derived : public Base
{
public:
Derived( PostConstructor const& helper = PostConstructor() )
: Base( helper )
{
}
};
or if the class has arguments:
class Base
{
std::string name;
public:
class PostConstructor
{
Base* owner;
std::string arg; // for example...
friend class Base;
public:
PostConstructor( std::string const& arg ) // implicit conversion!!
: owner( NULL ), arg( arg ) {}
~PostConstructor() { owner->parse(); }
operator std::string() const { return arg; }
};
Base( PostConstructor const& helper )
: name( helper )
{
helper.owner = this;
}
};
class Derived : public Base
{
public:
Derived( PostConstructor const& helper )
: Base( helper )
{
}
};
This works because the PostConstructor will be a temporary, destructed
at the end of the full expression (when Derived has been fully
constructed).
In both cases: the derived classes must co-operate (but they won't
compile if they don't). The trick can also fail if the class is
constructed in the middle of a more complicated expression. Something
like:
Derived(...).someFunction();
In this case, the end of the full expression will be after the return
from someFunction, which may be a little late to call parse().
Still, despite the limitations, I've found this useful on occasions.

Answer 4

Abstract or pure methods are a special case of virtual methods (All abstract or pure methods are virtual).
My previous answer is wrong, because I overlook the constructor. Constructor on C++, are not virtual, and does not allow to call virtual (abstract and not abstract methods), inside the constructors. If you where calling a non abstract overrided "parse" from another method that is not the constructor, will be fine.
The problem its not that the method its abstract, its that is called from a constructor.
#include <conio>
class Base
{
public:
// a constructor:
Base();
// "virtual and abstract" method:
virtual void parse() = 0;
// "virtual non abstract" method:
virtual void hello();
};
// Error: you cannot call a virtual method from a constructor,
// wheter is abstract or not:
Base::Base()
{
// error:
parse();
// error:
hello();
}
Base::hello()
{
cout << "Hello World\n";
}
class Sub : public Base
{
public:
Sub();
// forgot "virtual" here,
// other languages use "override" instead, here:
virtual void parse();
// another "overriden" methods:
virtual void parse();
};
// right: its important to call the base constructor,
// in this case:
Sub::Sub() : Base()
{
// ...
}
void Sub::parse()
{
// DO stuff
}
int main()
{
Base *MyBaseObject = new Base();
MyObject->parse();
Sub *MyObject = new Sub();
MyObject->parse();
return 0;
}
There is is a workaround for this. To call a virtual method,
like it was called from a constructor, Declaring a new method, that its called right after the constructor:
#include <conio>
class Base
{
public:
// a constructor:
Base();
// a "postconstructor" or "pseudoconstructor"
virtual void create();
// "virtual and abstract" method:
virtual void parse() = 0;
// "virtual non abstract" method:
virtual void hello();
};
// Error: you cannot call a virtual method from a constructor,
// wheter is abstract or not:
Base::Base()
{
// no virtual methods called here,
// wheter abstract or not
}
// its not a real constructor, just a virtual method:
void Sub::create()
{
// ...
}
Base::hello()
{
cout << "Hello World\n";
}
class Sub : public Base
{
public:
Sub();
virtual void create();
// forgot "virtual" here,
// other languages use "override" instead, here:
virtual void parse();
// another "overriden" methods:
virtual void parse();
};
// right: its important to call the base constructor,
// in this case:
Sub::Sub() : Base()
{
// ...
}
// its not a real constructor, just a virtual method:
void Sub::create() : create()
{
parse();
}
void Sub::parse()
{
// DO stuff
}
int main()
{
// this commented code, wont work
/*
Base *MyBaseObject = new Base();
MyObject->create();
MyObject->parse();
*/
// calling "pseudo-constructor",
// just after real constructor
Sub *MyObject = new Sub(); MyObject->create();
MyObject->parse();
return 0;
}
My mistake sorry.