How can I overload the new operator for a class type so that it allocates the memory on the stack instead of heap (basically so that the user doesn't have to call delete afterwards).
What about something like this:
class A{
private:
A(int i):
this->i(i);
{}
A a;
int i;
public:
void* operator new(size_t sz){
a(12);
}
};
Would the above solution work?
The new operator is designed to implement dynamic allocation (what you are calling "on the heap") and, although you can provide your own allocator, as such you cannot twist it into obeying the scoping rules of objects of automatic storage duration (what you are calling "on the stack").
Instead, write:
MyType myobject; // automatic storage duration
Or, if you don't mind dynamic storage duration but only want to avoid later manual destruction, use smart pointers:
std::unique_ptr<MyType> myptr(new myobject()); // unique, dynamic storage duration
std::shared_ptr<MyType> myptr(new myobject()); // shared, dynamic storage duration
Both of these are found in C++11 (std::) and Boost (boost::).
new?Another approach might be placement new but this is a dark and dangerous path to travel that I would certainly not recommend at this stage. Or, frankly, any stage... and you'd usually still need to do manual destruction. All you gain is using the keyword new, which seems pointless.
I think the good answer here is:
Don't overload operator new.
If you still want to go through that road, you can look at this question.
If not, you can always use smart pointers or shared pointers to avoid users having to delete allocated memory.
It seems that you don't know what you're asking. By definition, the new operator allocates memory on the heap. To create an object on the stack, simply declare it as a local variable.
Looking at what you actually want to do, you said that the reason you thought this would be awesome would be:
basically so that the user doesn't have to call delete afterwards
And that functionality is implemented using smart pointers. I highly suggest that you invest your time learning those instead.
Why not just automatic variable (it is "on stack" and does not need to call destructor manually:
int foo() {
A a;
int i;
...
// don't need to call delete
}
To answer your question literally, there is placement new, which takes memory from user - so you can have this memory as automatic buffer:
alignas(int) char buffer[sizeof(int)];
int* p = new (buffer) int;
// ^^^^^^^^
For non POD object - you do not need to call delete - but you must call destructor by hand:
class A { public: ~A(){} };
alignas(A) char buffer[sizeof(At)];
A* p = new (buffer) A;
// ^^^^^^^^
p->~A();
alignas is new in C++11 - in C++03 you must deal with proper alignment somehow differently. Proper aligned memory must be returned from new - otherwise the behavior is undefined.
