Best practice for deferred initialization of private class members - c++

Question

Is there a best practice for deferred initialization of a private class member M of class C? For example:
class C {
public:
C();
// This works properly without m, and maybe called at any time,
// even before startWork was called.
someSimpleStuff();
// Called single time, once param is known and work can be started.
startWork(int param);
// Uses m. Called multiple times.
// Guaranteed to only be called after startWork was called
doProcessing();
private:
M m;
};
class M {
M(int param);
};
Objects of class C can't be constructed because M doesn't have a default initializer.
If you can modify M's implementation, it's possible to add an init method to M, and make its constructor accept no arguments, which would allow constructing objects of class C.
If not, you can wrap the C's member m in std::unique_ptr, and construct it when it becomes possible.
However, both these solutions are prone to errors which would be caught in run-time. Is there some practice to make sure at compile-time that m is only used after its been initialized?
Restriction: An object of class C is handed to external code which makes use of its public interface, so C's public methods can't be split into multiple classes.

Answer 1

The best practice is to never used deferred initialisation.
In your case, ditch the default constructor for C and replace it with C(int param) : m(param){}. That is, class members get initialised at the point of construction using base member initialisation.
Using deferred initialisation means your object is potentially in an undefined state, and achieving things like concurrency is harder.

Answer 2

#define ENABLE_THREAD_SAFETY
class C {
public:
C();
// This works properly without m, and maybe called at any time,
// even before startWork was called.
someSimpleStuff();
// Called single time, once param is known and work can be started.
startWork(int param);
// Uses m. Called multiple times.
// Guaranteed to only be called after startWork was called
doProcessing();
M* mptr()
{
#ifdef ENABLE_THREAD_SAFETY
std::call_once(create_m_once_flag, [&] {
m = std::make_unique<M>(mparam);
});
#else
if (m == nullptr)
m = std::make_unique<M>(mparam);
#endif
return m.get();
}
private:
int mparam;
std::unique_ptr<M> m;
#ifdef ENABLE_THREAD_SAFETY
std::once_flag create_m_once_flag;
#endif
};
class M {
M(int param);
};
Now all you have to do is stop using m directly, and access it through mptr() instead. It will only create the M class once, when it's first used.

Answer 3

I would go with unique_ptr... Where do you see issues with that? When using M, you can easily check:
if(m)
m->foo();
I know that this is not a compile-time check but as far as I know, there is no check possible with current compilers. Code analysis would have to be quite complicated to see something like this because you can initialize m whenever you are willing to in any method or - if public/protected - even in another file. A compile time check would mean that lazy initialization is done at compile time but the very concept of lazy initialization is runtime-based.

Answer 4

Ok from what I understand of your problem, would this be a solution?
You put the functionality that does not require M into class D. You create D object and use it. Once you need M and you want to do the doProcessing() code, you create object of C, pass D to it and initialize it with param that you now have.
The below code is made just to illustrate the idea. You probably don't need startWork() to be a separate function in this case and its code could be written in the constructor of C
Note: I have made all the functions empty, so I could compile the code to check for syntax errors :)
class M
{
public:
M(int param) {}
};
class D
{
public:
D() {}
// This works properly without m, and maybe called at any time,
// even before startWork was called.
void someSimpleStuff() {}
};
class C
{
public:
C(D& d, int param) : d(d), m(param) { startWork(param); }
// Uses m. Called multiple times.
// Guaranteed to only be called after startWork was called
void doProcessing() {}
private:
// Called single time, once param is known and work can be started.
void startWork(int param) {}
D& d;
M m;
};
int main()
{
D d;
d.someSimpleStuff();
C c(d, 1337);
c.doProcessing();
c.doProcessing();
}

Answer 5

The question is "Is it possible to check at compile time that m is only used after it has been initialized without spliting the interface of C?"
The answer is No, you must use the type system to ensure that an object M is not used before initialized which would implies to split C interface. At compile time, compilers only know the type of objects, and the value of constant expressions. C cannot be a literal type. So you must use the type system: you must split C interface to ensure at compile time that M is only used after initialization.