我不确定你是否选择了正确的方法。
因为，首先你可以使用std::deque，它提供了栈所提供的所有功能，甚至更多。
因此，可能最好使用std::deque或std::vector。
另外，从标准容器派生不是最好的主意。您可以在SO上阅读到这方面的内容。
但是如果你想在特殊情况下这样做，那么只需要取top()的地址，这将是底层容器中的最后一个元素，如果你减去堆栈的size()（修正为1），那么你就有了一个指向底层容器开始的指针。
然后，您可以使用人工迭代器和下标运算符[]。
请参见以下示例：

#include <vector>
#include <stack>
#include <iostream>
#include <algorithm>
#include <iterator>

using Number = int;
using UnderlyingContainer = std::vector<Number>;
using Stack = std::stack< Number, UnderlyingContainer>;

using StackIterator = Number *const;

int main()
{
    // Put the test data onto the stack
    Stack myStack{ UnderlyingContainer {1,2,3,4,5} };

    if (not myStack.empty()) {

        // Get "iterators"
        StackIterator end = &myStack.top() + 1;
        StackIterator begin = end - myStack.size();

        Number *const & stk = begin;

        for (size_t i{}; i < myStack.size(); ++i)
            stk[i] = stk[i] + 10;

        for (size_t i{}; i < myStack.size(); ++i)
            std::cout << stk[i] << '\n';

        std::transform(begin, end, begin, [](const Number n) {return n - 10; });
        std::copy(begin, end, std::ostream_iterator<Number>(std::cout, "\n"));
    }
}

看起来我们找到了您想要的内容，但实际上，我们只是在底层容器上工作。

经过一番研究，我发现这个解决方案：

template <typename T, class container=std::deque<T>>
class MutantStack : public std::stack<T>
{
    public:
        MutantStack(){}
        ~MutantStack(){}
        MutantStack(const MutantStack &stack)
        {
            *this = stack;
        }
        typedef typename container::iterator iterator;
        iterator begin()
        {
            return this->c.begin();
        }
        iterator end()
        {
            return this->c.end();
        }
};

stack对象继承自deque类型，如下所示：

template <class Type, class Container = deque<Type> > class stack;

但它只公开了几个方法，例如：pop push empty swap和emplace，所以它也有deque迭代器，所以我就像上面一样使用它，c.begin()和c.end()中的c是一个在栈类中定义的container_type：

public:
    typedef _Container                               container_type;
protected:
    container_type c;

这意味着c是容器，当输入c.begin()时，我们得到Mutantstack中的第一个值;就像在数组上写value[0]，现在我的MutantStack类继承自std::stack类，而std::stack类本身继承自std::deque类：

`MutantStack -> std::stack -> std::deque`