0

我正在阅读“现代 C++ 设计”并想到了构建一个类似于指针的类，但它将在堆栈上而不是在堆上分配对象。它可以用在通常返回指向堆上分配的对象的指针的函数中。

在粘贴代码之前我会问我的问题：

  1. 已经有类似的东西了吗？
  2. 有机会使用吗？（当然如果更准确地实施）
  3. 为什么使用boost::mpl::max_element（注释掉）的版本不起作用？
  4. 如果没有参数，如何调用模板化构造函数？（我的意思是：）template <class U> StackPointer() { ... }？

这是代码：

#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;
}
4

2 回答 2

0

Boost optional与您所描述的非常相似。

它使用指针语法，因此它可以模拟NULL指针语言中的指针。

于 2013-03-07T23:27:55.210 回答
0

您不能在堆栈上分配一个对象，然后返回任何指向它的东西。从函数返回后，堆栈帧消失了，指向该内存无效。

当您在函数中声明局部变量时，它们被分配在堆栈上，然后在函数返回之前被销毁，并且堆栈框架已过时。

因此，您可以为堆上的对象分配内存并通过指针引用它们。或者在堆栈上的函数中有局部变量。

或者你的意思是作为一种处理被调用函数的返回值的方法？但是，无论如何您都需要将数据从堆复制到堆栈，所以T obj = *foo()如果您需要/想要堆栈上的副本，为什么不直接使用。

对我来说，这听起来像是您试图使编译器已经有效处理的事情复杂化。

于 2013-03-07T23:35:41.470 回答