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.

Answer 3

Benjamin Bannier's suggestion works for me on GCC 4.7.2 with no special compiler flags (i.e., default optimization), or with -O0, -O1, -O2, or -O3:

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

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

  c.doStuff();

  return 0;
}

I get the same results when I try it on GCC 3.4.4 (circa 2004), GCC 3.4.6 (2006), GCC 4.2.4 (2007), and GCC 4.7.2 (2012).

Answer 4

Try, this might avoid extra copy due to compiler copy elision:

MyClass makeInstance(int a, string& b) {
    if (something) {
        return MyClass(a);
    } else {
        return MyClass(b);
    }
}

I tried it and in my case I see only one object constructed and destroyed.

Answer 5

Modern approach

Since C++11 we have std::aligned_storage, which can be used to reserve stack space for an object in a type-safe way without invoking its constructor. See here: https://en.cppreference.com/w/cpp/types/aligned_storage.

I had a particular usage scenario for this, and simply post my solution. Should be fairly simple to replicate and customize for other needs:

#include <new>
#include <iostream>

template<typename T>
using AlignedStorage = std::aligned_storage<sizeof(T), alignof(T)>::type;

struct A
{
    A(int _x) : x(new int(_x)) {}
    ~A() { delete x; }
    int* x;
};

struct B
{
    AlignedStorage<A> a;
};

B* create_b()
{
    auto res = new B(); // the member a does not get constructed!

    new (&res->a) A(42); // does not allocate, but calls constructor!

    return res;
}

void destroy_b(B* b)
{
    (reinterpret_cast<A*>(&b->a))->~A(); // destruct, but not deallocate!

    delete b; // be can safely be deallocated
}

int main()
{
    B* b = create_b();
    std::cout << "b->a = " << *(reinterpret_cast<A*>(&b->a)->x) << '\n';
    destroy_b(b);

    return 0;
}

Remarks

For the example above, the struct B gets allocated on the heap, but it contains a struct A which is stored as a value. The code was compiled with g++-11 -std=c++20 example.cpp, which means that it requires C++20. For C++11 I get some compiler errors, so likely other stuff has to be added for that to work.

Answer 6

There is only one good solution to this that avoids any unnecessary constructor calls: lazy initialization. Have only one constructor, that simply gets your object into a defined state, and do the actual initialization in an init() method. Like this:

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

    void init(int a) {
        std::cout << "MyClass(" << a << ")" << std::endl;
        initialized = true;
    };

    void init(const std::string& a) {
        std::cout << "MyClass(\"" << a << "\")" << std::endl;
        initialized = true;
    };

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

private:
    bool initialized;
};

Then you can easily do the following, initializing you object exactly once without using any kind of hack:

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