3D游戏引擎底层数据结构的封装之Stack

笔者介绍：姜雪伟，IT公司技术合伙人，IT高级讲师，CSDN社区专家，特邀编辑，畅销书作者，国家专利发明人;已出版书籍：《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社等。

数据结构系列已经给读者介绍了一些常用的，这些也是商业引擎底层的封装，给读者展示也是告诉读者其实引擎内部的技术并没有那么神秘，都是人写的。但是作为开发者，我们也要学着写一些数据结构的封装，这并不是告诉读者去自己开发引擎，这是不现实的。但是对于引擎使用的技术点，我们至少做到自己也可以去封装一些常用算法。要想从本质上提升自己的技术，这些算法还是应该掌握的。

     本文主要给读者介绍的是关于堆栈的封装，也被称为后进先出的数据结构。关于堆栈的基本属性如果读者不清楚可以去网上学习或者查阅大学课程《数据结构》课本。堆栈的封装还是要清楚它包含哪些方法，比如进栈，出栈，获取栈的元素，栈是否为空等等，我们实现是底层的封装，换句话说应该使用哪种数据结构存储堆栈信息。下面是完整的源代码：

template<class TYPE> class Stack
{
public:
    /// constructor
    Stack();
    /// copy constructor
    Stack(const Stack<TYPE>& rhs);

    /// assignment operator
    void operator=(const Stack<TYPE>& rhs);
    /// access element by index, 0 is the topmost element
    TYPE& operator[](IndexT index) const;
    /// equality operator
    bool operator==(const Stack<TYPE>& rhs) const;
    /// inequality operator
    bool operator!=(const Stack<TYPE>& rhs) const;
    /// returns number of elements on stack
    SizeT Size() const;
    /// returns true if stack is empty
    bool IsEmpty() const;
    /// remove all elements from the stack
    void Clear();
    /// return true if stack contains element
    bool Contains(const TYPE& e) const;

    /// push an element on the stack
    void Push(const TYPE& e);
    /// get reference of topmost element of stack, without removing it
    TYPE& Peek() const;
    /// get topmost element of stack, remove element
    TYPE Pop();

private:
    Array<TYPE> stackArray;
};

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
Stack<TYPE>::Stack()
{
    // empty
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
Stack<TYPE>::Stack(const Stack<TYPE>& rhs)
{
    this->stackArray = rhs.stackArray;
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
void
Stack<TYPE>::operator=(const Stack<TYPE>& rhs)
{
    this->stackArray = rhs.stackArray;
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
TYPE&
Stack<TYPE>::operator[](IndexT index) const
{
    return this->stackArray[this->stackArray.Size() - 1 - index];
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
bool
Stack<TYPE>::operator==(const Stack<TYPE>& rhs) const
{
    return this->stackArray == rhs.stackArray;
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
bool
Stack<TYPE>::operator!=(const Stack<TYPE>& rhs) const
{
    return this->stackArray != rhs.stackArray;
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
bool
Stack<TYPE>::Contains(const TYPE& e) const
{
    return (InvalidIndex != this->stackArray.FindIndex(e));
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
void
Stack<TYPE>::Clear()
{
    this->stackArray.Clear();
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
SizeT
Stack<TYPE>::Size() const
{
    return this->stackArray.Size();
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
bool
Stack<TYPE>::IsEmpty() const
{
    return this->stackArray.IsEmpty();
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
void
Stack<TYPE>::Push(const TYPE& e)
{
    this->stackArray.Append(e);
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
TYPE&
Stack<TYPE>::Peek() const
{
    return this->stackArray.Back();
}

//------------------------------------------------------------------------------
/**
*/
template<class TYPE>
TYPE
Stack<TYPE>::Pop()
{
    TYPE e = this->stackArray.Back();
    this->stackArray.EraseIndex(this->stackArray.Size() - 1);
    return e;
}

关于引擎底层的基本算法封装到此为止就给读者介绍完了，后面还会对一些引擎中使用的算法进行封装，我会逐步的深入讲解。