对象从堆栈中弹出自身。

Question

示例代码：

class A
{
public:
    A(std::stack<A>* pStack){
        this->pStack = pStack;
    }

    void popMe(){
        pStack->pop();
    }
protected:
    std::stack<A>* pStack;
};

int main()
{
    std::stack<A> s;
    s.push(A(&s));
    s.top().popMe();
    return 0;
}

对象堆栈(或具有类pop方法的其他容器)，每个对象都有指向堆栈的指针，这样它就可以弹出自己(或其他类型容器的情况下的任何其他对象)。我的问题是：

1. 对象从堆栈中弹出时是否被删除？
2. 调用popMe方法安全吗？
3. 是的，我知道这段代码很奇怪，很难理解/调试。如何管理堆栈上的对象与堆栈(或包含此堆栈的对象)之间的通信，有什么更好的想法吗？

Answer 1

1堆栈上的对象总是被销毁的！

2方法不安全。如果对象不是当前顶部的对象怎么办。

3您可以扩展std：：堆栈适配器并通知被移除的对象：

#include <iostream>
#include <stack>

template <typename T>
class Stack
{
    private:
    typedef std::stack<T> stack_type;

    public:
    typedef typename stack_type::value_type value_type;
    typedef typename stack_type::reference reference;
    typedef typename stack_type::const_reference const_reference;
    typedef typename stack_type::size_type size_type;
    typedef typename stack_type::container_type container_type;

    public:
    explicit Stack(const container_type& container = container_type())
    : m_stack(container)
    {}

    bool empty() const { return m_stack.empty(); }
    size_type size() const { return m_stack.size(); }
    reference top() { return m_stack.top(); }
    const_reference top() const { return m_stack.top(); }
    void push(const value_type& x) { m_stack.push(x); }
    void push(value_type&& x) { m_stack.push(std::move(x)); }

    template<typename... Args>
    void emplace(_Args&&... args) {
        m_stack.emplace(std::forward<Args>(args)...);
    }

    void pop() {
        top().stack_pop_event(*this);
        m_stack.pop();
    }

    void swap(Stack& other) {
        m_stack.swap(other.m_stack);
    }

    private:
    stack_type m_stack;
};

class A
{
    public:
    void stack_pop_event(const::Stack<A>&){
        std::cout << "Pop\n";
    }
};

int main()
{
    Stack<A> s;
    s.push(A());
    s.pop();
    return 0;
}

(C++11)

Answer 2

对象的析构函数将被调用。

你不检查指针是否为零。另外，想象下面的代码：

std::stack<A> s;
s.push(A(&s));
auto& head = s.top();
s.push(A(&s));
// ...
head.popMe(); //pops another element

3-见boost：：侵入式容器。它有脱钩钩。

Answer 3

1. 对象从堆栈中弹出时是否被删除？

是。但这将是你推进去的那本。

1. 调用popMe方法安全吗？

是

您可以在这里找到堆栈文档，http://www.cplusplus.com/reference/stack/stack/push/

void push (const value_type& val);

在堆栈顶部插入一个新元素，位于其当前顶部元素的上方。此新元素的内容被初始化为val的副本。

因此std：：堆栈只存储副本。如果希望它负责释放原始元素，则应使用

std::stack<std::shared_ptr<A>>