StackPointer template

Question

I'm reading "Modern C++ design" and hit on an idea to build a class that would act like a pointer but it would allocate object on the stack instead of on the heap. It could be used in functions that would normally return a pointer to an object allocated on the heap.

I will ask my questions before pasting the code:

1. Is there something similar already?
2. Has it a chance to be used? (if implemented more accurately of course)
3. Why version that uses boost::mpl::max_element (commented out) doesn't work?
4. How to call templated constructor if it had no parameter? (I mean: template <class U> StackPointer() { ... })?

Here is the code:

#include <iostream>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/max_element.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/front.hpp>

template <class V, size_t VS=boost::mpl::size<V>::type::value>
struct max_size
{
    typedef typename boost::mpl::pop_front<V>::type subvector;
    typedef typename boost::mpl::front<V>::type front_type;
    static size_t const value = sizeof(front_type) > max_size<subvector>::value ?
                sizeof(front_type) : max_size<subvector>::value;
};

template <class V>
struct max_size<V, 0>
{
    static size_t const value = 0;
};

class StackPointerImplBase
{
public:
    virtual void clone(char const* from, char* to) const = 0;
};

template <class T>
class StackPointerImpl : public StackPointerImplBase
{
public:
    virtual void clone(char const* from, char *to) const
    {
        new(to) T(*reinterpret_cast<T const*>(from));
    }
};

template <class Base, class DerivedTypes>
class StackPointer
{
public:
    template <class T>
    StackPointer(T const& t)
    {
        std::cout << "Size of m_buf: "  << sizeof(m_buf) << std::endl;
        new(m_impl_buf) StackPointerImpl<T>();
        new(m_buf) T(t);
    }

    StackPointer(StackPointer const& sp)
    {
        //TODO: COPY m_impl_buf
        reinterpret_cast<StackPointerImplBase const*>(sp.m_impl_buf)->clone(sp.m_buf, m_buf);
    }

public:
    ~StackPointer()
    {
        get_pointer()->~Base();
    }

    Base* operator->()
    {
        return get_pointer();
    }

private:
    Base* get_pointer()
    {
        return reinterpret_cast<Base*>(m_buf);
    }

private:
    //typedef max_size<DerivedTypes> xxx_type;
    //typedef typename boost::mpl::max_element<DerivedTypes>::type::type biggest_type;
    //char m_buf[sizeof(typename boost::mpl::max_element<DerivedTypes>::type::type)];
    char m_buf[max_size<DerivedTypes>::value];
    char m_impl_buf[sizeof(StackPointerImplBase)];
};

class Shape
{
public:
    virtual ~Shape() {}

    virtual void say() const { std::cout << "I'm a shape" << std::endl; }
};

class Circle : public Shape
{
public:
    virtual void say() const { std::cout << "I'm a circle" << std::endl; }

private:
    float m_x;
    float m_y;
    float m_r;
};

class Line : public Shape
{
public:
    virtual void say() const { std::cout << "I'm a Line" << std::endl; }

private:
    float m_x1;
    float m_y1;
    float m_x2;
    float m_y2;
};


typedef StackPointer<Shape, boost::mpl::vector<Circle, Line> > ShapeStackPtr;

ShapeStackPtr read_shape()
{
    Line c;
    return ShapeStackPtr(c);
}


int main(int argc, char *argv[])
{

    {
        ShapeStackPtr shape = read_shape();
        shape->say();
    }

    return 0;
}

Answer 1

Boost optional is pretty similar to what you describe.

It uses pointer syntax so it can simulate what would be a NULL pointer in pointer-speak.

Answer 2

You can not allocate an object on the stack and then return anything that points to it. After you return from a function that stack frame is gone and it is not valid to point to that memory.

When you declare local variables in a function they are allocated on the stack then destroyed before the function return and the stack frame made obsolete.

So you can either allocate memory for objects on the heap and refer to them by pointers. Or have local variables in functions on the stack.

Or do you mean as a way to handle return values from called functions? But then you need to make a copy of the data from the heap to the stack anyway so why not just use T obj = *foo() if you need/want a copy on the stack.

To me it sounds like you are trying to complicate something that is already handled efficiently by the compiler.