Can I make a variable _const from now on_?

Question

I'm using a library that has a class with an init function distinct from its constructor. Every time I make a new instance I need to call, for example:

MyClass a;
a.init();

Since init is not const, this prevents me from creating const instances (I can't write const MyClass a). Is there some way to call init and then declare from "here on out" (I guess for the remainder of the scope) my variable is const?

This works, but relies on not touching the original variable:

MyClass dont_touch;
dont_touch.init();
const MyClass & a = dont_touch;

Answer 1

If you're using C++11 you could use a lambda function

const MyClass ConstantVal = []{ 
    MyClass a;
    a.init(); 
    return a; 
}();

This allows you to keep the initialization in place while never giving outside access to the mutable object. see also: http://herbsutter.com/2013/04/05/complex-initialization-for-a-const-variable/

Answer 2

You can create a wrapper class and use that instead.

If MyClass has a virtual destructor you can feel safe deriving from it like this:

class WrapperClass : public MyClass 
{
public:
    WrapperClass()
    {
        init(); // Let's hope this function doesn't throw
    }
};

Or write a class that contains the MyClass instance

class WrapperClass
{
public:
    WrapperClass()
    {
        m_myClass.init(); // Let's hope this function doesn't throw
    }
    operator MyClass&() {return m_myClass;}
    operator const MyClass&() const {return m_myClass;}
private:
    MyClass m_myClass;
};

Or write a template to solve this general problem using one of the two solutions above: eg.

template <class T> class WrapperClass : public T
{
public:
    WrapperClass()
    {
        T::init();
    }
};

typedef WrapperClass<MyClass> WrapperClass;