CODEWITHSUNDEEP
c++stacknew-operator
user34537
user34537

Reputation:

new on stack instead of heap (like alloca vs malloc)

Is there a way to use the new keyword to allocate on the stack (ala alloca) instead of heap (malloc) ?

I know I could hack up my own but I'd rather not.

Upvotes: 18

Views: 13465

Answers (4)

David Allan Finch
David Allan Finch

Reputation: 1424

You could do:

Whatever* aWhatever = new ( alloca(sizeof(Whatever)) ) Whatever;

You could uses a RAII class to do the destruction I suppose (EDIT: Also see this other answer for more information on potential problems with this approach):

template <class TYPE>
class RAII
    {
    public:
        explicit RAII( TYPE* p ) : ptr(p) {}
        ~RAII() { ptr->~TYPE(); }
        TYPE& operator*() const { return *ptr; }
    private:
        TYPE* ptr;
    }

void example()
    {
    RAII<Whatever> ptr = new ( alloca(sizeof(Whatever)) ) Whatever;
    }

You could use a macro to hide the alloca.

Regards DaveF

Upvotes: 8

Carl Seleborg
Carl Seleborg

Reputation: 13305

Be careful when using _alloca() with GCC

GCC has a bug which makes _alloca() incompatible with SJLJ exception handling in C++ (Dwarf2 is reported to work correctly). When an exception is thrown out of the function allocating the memory, the bug causes stack corruption before the destructors get to run. This means that any RAII class working on the allocated object(s) has to run in another function to work properly. The proper way of doing it looks like this:

void AllocateAndDoSomething()
{
  Foo* pFoo = reinterpret_cast<Foo*>(_alloca(sizeof(Foo)));
  new (pFoo) Foo;

  // WARNING: This will not work correctly!
  // ScopedDestructor autoDestroy(pFoo);
  // pFoo->DoSomething();

  // Instead, do like this:
  DoSomething(pFoo);
}

void DoSomething(Foo* pFoo)
{
  // Here, destruction will take place in a different call frame, where problems
  // with _alloca() automatic management do not occur.
  ScopedDestructor autoDestroy(pFoo);
  pFoo->DoSomething();
}

Upvotes: 3

derobert
derobert

Reputation: 51167

Jeffrey Hantin is quite correct that you can use placement new to create it on the stack with alloca. But, seriously, why?! Instead, just do:

class C { /* ... */ };

void func() {
    C var;
    C *ptr = &var;

    // do whatever with ptr
}

You now have a pointer to an object allocated on the stack. And, it'll properly be destroyed when your function exists.

Upvotes: 12

Jeffrey Hantin
Jeffrey Hantin

Reputation: 36524

To allocate on the stack, either declare your object as a local variable by value, or you can actually use alloca to obtain a pointer and then use the in-place new operator:

void *p = alloca(sizeof(Whatever));
new (p) Whatever(constructorArguments);

However, while using alloca and in-place new ensures that the memory is freed on return, you give up automatic destructor calling. If you're just trying to ensure that the memory is freed upon exit from the scope, consider using std::auto_ptr<T> or some other smart pointer type.

Upvotes: 25

Related Questions