stack.h
#pragma once
template<class T>
class Stack {
public:
Stack();
Stack(const Stack<T> &s);
~Stack();
void push(const T& elem);
void pop();
const T & top();
size_t size();
bool empty();
private:
T *m_elem;
int m_top; // 栈顶坐标
};
template<class T>
inline Stack<T>::Stack() {
m_elem = nullptr;
m_top = -1;
}
template<class T>
inline Stack<T>::Stack(const Stack<T>& s) {
this->m_elem = s.m_elem;
this->m_top = s.m_top;
}
template<class T>
inline Stack<T>::~Stack() {
m_elem = nullptr;
delete m_elem;
m_top = -1;
}
template<class T>
inline void Stack<T>::push(const T& elem) {
if (this->empty()) {
m_elem = new T[m_top + 1];
m_elem[++m_top] = elem;
}
else {
Stack<T> s = *this;
m_elem = nullptr;
delete m_elem;
m_top++;
m_elem = new T[m_top + 1];
for (int i = 0; i < m_top + 1; ++i) {
m_elem[i] = s.m_elem[i];
}
m_elem[m_top] = elem;
}
}
template<class T>
inline void Stack<T>::pop() {
if (m_top == -1) {
return;
}
m_top--;
}
template<class T>
inline const T & Stack<T>::top()
{
return m_elem[m_top];
}
template<class T>
inline size_t Stack<T>::size()
{
return m_top + 1;
}
template<class T>
inline bool Stack<T>::empty() {
return m_top == -1;
}
vector.h
#pragma once
template<class T>
class Vector {
public:
Vector();
Vector(size_t n);
Vector(const Vector<T> &v);
~Vector();
const T& front();
const T& back();
void push_back(const T &elem);
void pop_back();
void erase(const size_t &index);
bool empty();
size_t size();
T& operator[](size_t index)const;
private:
T *m_elem;
size_t m_size;
};
template<class T>
inline Vector<T>::Vector() {
m_elem = nullptr;
m_size = 0;
}
template<class T>
inline Vector<T>::Vector(size_t n) {
this->m_elem = new T[m_size];
this->m_size = n;
}
template<class T>
inline Vector<T>::Vector(const Vector<T>& v) {
this->m_elem = v.m_elem;
this->m_size = v.m_size;
}
template<class T>
inline Vector<T>::~Vector() {
m_elem = nullptr;
m_size = 0;
}
template<class T>
inline const T & Vector<T>::front() {
return m_elem[0];
}
template<class T>
inline const T & Vector<T>::back() {
return m_elem[m_size - 1];
}
template<class T>
inline void Vector<T>::push_back(const T & elem) {
m_size++;
Vector<T> temp = *this;
m_elem = new T[m_size];
for (size_t i = 0; i < m_size - 1; ++i) {
m_elem[i] = temp[i];
}
m_elem[m_size - 1] = elem;
}
template<class T>
inline void Vector<T>::pop_back() {
m_size--;
Vector<T> temp = *this;
m_elem = new T[m_size];
for (size_t i = 0; i < m_size; ++i) {
m_elem[i] = temp[i];
}
}
template<class T>
inline void Vector<T>::erase(const size_t & index)
{
m_size--;
Vector<T> temp = *this;
m_elem = new T[m_size];
size_t j = 0;
for (size_t i = 0; i <= m_size; ++i) {
if (i == index) {
j = i;
continue;
}
m_elem[j++] = temp[i];
}
}
template<class T>
inline bool Vector<T>::empty()
{
return m_size == 0;
}
template<class T>
inline size_t Vector<T>::size()
{
return m_size;
}
template<class T>
inline T& Vector<T>::operator[](size_t index) const {
return m_elem[index];
}