Allocate memory on stack without calling constructor

Question

I'd like to keep MyClass in the stack memory (simpler, faster) in the following code, but avoid calling the default constructor:

#include <iostream>

class MyClass {
public:
  MyClass() {
    std::cout << "MyClass()" << std::endl;
  }

  MyClass(int a) {
    std::cout << "MyClass(" << a << ")" << std::endl;
  }

  MyClass(const std::string& a) {
    std::cout << "MyClass(\"" << a << "\")" << std::endl;
  }

  void doStuff() {
    std::cout << "doStuff()" << std::endl;
  }
};

int main(int argc, char* argv[]) {
  bool something;
  if (argc > 1)
    something = 1;
  else
    something = 0;

  MyClass c;
  if (something)
    c = MyClass(1);
  else
    c = MyClass("string");
  c.doStuff();

  return 0;
}

As far as I know, the only way to avoid calling the default constructor would be to use a pointer, but then I would have to allocate in the heap and deal with memory management. Is there any other way?

Answer 1

If you don't mind using a total hack, you can try a placement new.

char mem[sizeof(MyClass)] alignas(MyClass);
auto custom_deleter = [](MyClass *p){ p->~MyClass(); };
std::shared_ptr<MyClass> c(new (mem) MyClass, custom_deleter);

You use the alignas to make sure the automatic memory allocated is properly aligned for your object. The custom_deleter function calls the destructor without freeing the memory, which is needed when using automatic memory with a smart pointer. A demo of the code can be found here.

But, for your problem a more elegant solution exists. You can use a copy constructor instead:

  MyClass c = something ? MyClass(1) : MyClass("string");
  c.doStuff();

Answer 2

You're right. It isn't possible for you do avoid calling the default constructor, unless you want to duplicate some code like shown below.

if (something) {
    MyClass c(1);
    c.doStuff();
}
else {
    MyClass c("string");
    c.doStuff();
}

I would recommend that you create the object of the heap, but delegate the memory handling to another class. With C++03, there is the std::auto_ptr class which can be used. With C++11, auto_ptr has be deprecated, and instead you can use shared_ptr or unique_ptr.

Here is some example code using shared_ptr -

std::shared_ptr<MyClass> c;
if (something)
    c.reset(new MyClass(1));
else 
    c.reset(new MyClass("string"));

c->doStuff();

The object will automatically be deleted when it goes out of scope.

In general, it is recommended to use smart pointers instead of doing the memory management yourself. This is especially useful when you're dealing with code that can throw exceptions.