Pure virtual function which must set variable - c++

Question

recently i have read some about pure virtual function concept in c++ and i wonder, given following code:
class First
{
public:
virtual void init() = 0;
protected:
bool initialized;
};
class Second : public First
{
public:
void init() { ((*someting*) ? (initialized=true) : (initialized=false));
};
if creator of First class wanted to ensure the implementation of init() MUST set initialized variable either true or false how can they do that? Is there an option to enforce implementation of pure virtual function to set any variable inherited from base class?

Answer 1

You can make init protected and have it return bool.
Then have a new initialize method which is public and also sets the initialized member.
Since init now has a return value, it must be set by anyone who implements derived classes.
class First
{
public:
void initialize() { initialized = init(); }
protected:
virtual bool init() = 0;
bool initialized;
};
class Second : public First
{
public:
bool init() { return (*something*); }
};

Answer 2

You cannot check if initialized has been set or not, because it cannot represent the third state "undefined".
Solution 1
Protect the pure virtual function, make it return the initialized value and call it via a non-virtual wrapper
class First
{
public:
void init()
{
initialized = initImplementation();
// check initialized here
}
protected:
virtual bool initImplementation() = 0;
bool initialized;
};
Solution 2
Change initialized to an enumeration with the states undefined, non-initialized, initialized, protect the pure virtual function and call it via a non-virtual wrapper, that then checks if the variable has been set:
class First
{
public:
void init()
{
initImplementation();
// check initialized here
}
protected:
virtual void initImplementation() = 0;
enum
{
undefined,
initialized,
uninitialized
} initialized;
};
Solution 3
Get rid of initialized, just throw an exception in init() if something goes wrong. The caller will then know that something went wrong.
As a sidenote, you can throw also from the constructor.

Answer 3

Well, while the direct answer to your question is no. There is some technique you can employ to get a guaranteed call of your init function.
Let's say you have the following base class:
class Base
{
public:
virtual void init() = 0;
private:
bool initialized = false;
};
void Base::init()
{
std::cout << "Called from base!\n";
initialized = true;
}
And the following derived:
class Derived: public Base
{
friend class Enforcer<Derived>;
public:
void init() override
{
std::cout << "Called from derived!\n";
}
private:
Derived()
{
}
private:
using BaseClass = Base;
};
Look at the private constructor and the friend declaration: you can no more create this class without help of the Enforcer class(this step is not really required but it will really force any user of the Derived class to use Enforcer). And now we need to write the Enforcer class, here it is:
template<typename T>
class Enforcer: public T
{
public:
template<typename... Args>
Enforcer(Args&&... arg): T(std::forward<Args>(arg)...)
{
}
void init() override
{
T::init();
T::BaseClass::init();
}
};
The whole example on the ideone.
Yes it has its drawbacks(you need to add some additional stuff to the Derived class) but it solves the requirement pretty neatly, in my opinion.