Question

Is there a way to define a macro (or something similar) that would allow objects to be allocated on the stack or on the heap, cleanly?

eg. Current code:

A a; a.someFunc(); 

The simplest suggestion might be the following, but as you can see below, it’s not very clean to maintain 2 sets of code.

#ifdef USE_STACK   A a;   a.someFunc(); #elseif USE_HEAP   A* a = new A();   a->someFunc(); #endif 

I am looking for a design pattern / proxy class that can be use to compile the code either way, depending on the needs of our customer.

Edit: The code is used to build a library for embedded device / (embedded) Linux / Windows Mobile. Most customers want stack based allocation only. A few others have asked to trade stack for heap.

Thanks, Charles

Answer 1

EDIT: improved to allow calling of wrapped member functions through operator->

Expanding on Manuel’s answer to make it more complete, try this:

#include <iostream>  #define USE_STACK  template <class T> class HeapWrapper { #ifdef USE_STACK     T obj_; #else     T *obj_; #endif public: #ifdef USE_STACK     HeapWrapper() : obj_() {}      template <class A1>     HeapWrapper(const A1 &a1) : obj_(a1) {}      template <class A1, class A2>     HeapWrapper(const A1 &a1, const A2 &a2) : obj_(a1, a2) {}      // etc  #else     HeapWrapper() : obj_(new T()) {}     ~HeapWrapper() { delete obj_; }      template <class A1>     HeapWrapper(const A1 &a1) : obj_(new T(a1)) {}      template <class A1, class A2>     HeapWrapper(const A1 &a1, const A2 &a2) : obj_(new T(a1, a2)) {}      // etc #endif  #ifdef USE_STACK     operator const T &() const    { return obj_; }     operator T &()                { return obj_; }     T *operator->()               { return &obj_; }     T& operator*()                { return obj_; } #else     operator const T &() const    { return *obj_; }     operator T &()                { return *obj_; }     T *operator->()               { return obj_; }     T& operator*()                { return *obj_; } #endif      // cast operators makes this work nicely     HeapWrapper &operator=(const T &rhs) { *obj_ = rhs; return *this;} };   class A { public:     void member(int x) {         std::cout << x << std::endl;     } };   int main() {     HeapWrapper<int> x1(5);     HeapWrapper<int> x2;     HeapWrapper<int> x3 = x1;     HeapWrapper<int> x4 = 3;      std::cout << x1 << ' ' << x2 << ' ' << x3 << ' ' << x4 << std::endl;      // example using a custom class's members..     HeapWrapper<A> a1;     a1->member(5); }