21

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;
Improve this question
8
  • The answer is no. Like you, I wish it was yes. Commented Apr 30, 2014 at 23:56
  • You can also use const_cast for the init call to do it quick and dirty. That is, declare the object const, and const_cast around the object for the init call. However, const_cast is generally considered bad practice, and I've gotta say I think the templated solution is super slick. Commented May 1, 2014 at 1:36
  • 1
    @Apriori Definitely Undefined Behaviour. Can't const_cast away const from an a defined const object and do non-const stuff to it. Commented May 1, 2014 at 1:49
  • @Andre Kostur: Thank you, good call, I never realized or forgot this was undefined behavior. On the plus side you can see how much I use const_cast. C++ gave me the gun... Commented May 1, 2014 at 2:36
  • 1
    You can cast away const if you have a const reference to an underlying object which is non-const .. but that is not the case in this example Commented May 1, 2014 at 5:26

4 Answers 4

Reset to default
16

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/

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

I think this is more optimizable than my solution also, since the compiler can then assume that the object is never modified.
This answers my specific question. Though I could have asked a more general question where a.init() is replaced with some arbitrary operation that might not reasonably fit in the lambda.
9

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;
Improve this answer

2 Comments

It's probably worth noting such a derived class can be defined within and local to the function it's used if desired. But using the template solution is even better and sidesteps this, because you can just instantiate at will.
It's perfectly fine for init to throw. Let's hope it doesn't return an error code. The usual reason for init functions is that the developer knows an error can occur, but doesn't know exceptions, so he can't report the error if it happens in the ctor.
5

Create a function that wraps the first two lines and gives you an object that is ready to go.

MyClass makeMyClass() { MyClass a; a.init(); return a; } // Now you can construct a const object or non-const object. const MyClass a = makeMyClass(); MyClass b = makeMyClass();

Update

Using makeMyClass() involves construction and destruction of a temporary object everytime the function is called. If that becomes a significant cost, makeMyClass() can be altered to:

MyClass const& makeMyClass() { static bool inited = false; static MyClass a; if ( !inited ) { inited = true; a.init(); } return a; }

It's usage, as described earlier, will continue to work. In addition, once can also do this:

const MyClass& c = makeMyClass();
Improve this answer

5 Comments

Yes, it does come at the cost of a copy.
@mangledorf I'm not sure about this, but return value optimization might be useful. So if I understand it right, if you use -O3, I don't think you need to worry about this. Just a thought.
Even if RVO is present you need to make sure that your class's copy-constructor is correct.
const MyClass a = makeMyClass(); may be also const MyClass& a = makeMyClass();.
If the class is move enabled (using c++11) then it is guaranteed not to make a copy.
1

You can actually do it quite simply, even without C++11 and lambdas:

const MyClass a; { MyClass _a; _a.init(); std::swap(const_cast<MyClass&>(a), _a); }

The use of const_cast is admittedly a bit of a hack, but it won't break anything as const is quite a weak specifier. At the same time, it is quite efficient, as the MyClass object is only swapped, not copied (most reasonable expensive-to-copy objects should provide a swap function and inject an overload of std::swap).

Without the cast, it would require a helper:

struct Construct_Init { operator MyClass() const { MyClass a; a.init(); return a; } }; const MyClass a = Construct_Init();

This can be like this in a function (the Construct_Init structure needs not be declared at namespace scope), but it is a bit longer. The copy of the object may or may not be optimized away using copy elision.

Note that in both cases, the return value of init() is lost. If it returns a boolean where true is success and false is failure, it is better to:

if(!a.init()) throw std::runtime_error("MyClass init failed");

Or just make sure to handle the errors appropriately.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.