#include <iostream>
#include<string>
#include <assert.h>
using namespace std;
struct _TrueType
{
static int Get() //使用static修饰成员函数的话,访问该成员函数的话可以用通过类作用域访问,
//不使用static修饰成员函数的话,访问该成员函数,要先进行对象的创建,然后用成员操作符访问
{
return true;
}
};
struct _FalseType
{
static int Get()
{
return false;
}
};
template<class T>
struct TypeTraits
{
typedef _FalseType ISPODType;//POD:plain old data 平凡类型(无关痛痒的类型)--基本类型
};
template<>
struct TypeTraits<int>
{
typedef _TrueType ISPODType;
};
template<>
struct TypeTraits<char>
{
typedef _TrueType ISPODType;
};
template<>
struct TypeTraits<double>
{
typedef _TrueType ISPODType;
};
template<>
struct TypeTraits<long>
{
typedef _TrueType ISPODType;
};
//使用萃取判断类型的Get函数判断是否是 POD类型来处理
template <class T>
void Copy(const T* src ,T* dest, size_t size)
{
cout<<"_TrueType:"<<typeid(T).name()<<endl;
if(TypeTraits<T>::ISPODType::Get())
{
memcpy(dest ,src, size);
}
else
{
for (size_t i=0; i<size; ++i)
{
dest[i] = src[ i];
}
}
}
template<class T>
class Stack
{
public:
Stack()
:_pData(new T[3])
,_size(0)
,_capacity(3)
{}
Stack(const Stack<T>& s)
{
size_t capacity = s._capacity;
_pData = new T[capacity];
size_t size = s._size;
for(size_t idx=0; idx<size; ++idx)
{
_pData[idx] = s._pData[idx];
}
_size = size;
_capacity = capacity;
}
Stack<T>& operator=(const Stack<T>& s)
{
if(this != &s)
{
size_t capacity = s._capacity;
size_t size = s._size;
if(_capacity < size)
{
_pData = new T[capacity];
for(size_t idx=0; idx<size; ++idx)
{
_pData[idx] = s._pData[idx];
}
_size = size;
_capacity = capacity;
}
}
return *this;
}
void Push(const T& data)
{
CheckCapacity();
if(_size == 0)
_pData[0] = data;
else
{
_pData[_size-1] = data;
}
_size++;
}
void Pop()
{
assert(!Empty());
--_size;
}
bool Empty()const
{
if(_size == 0)
return true;
return false;
}
T& Top()
{
return _pData[_size-1];
}
size_t Size()const
{
return _size;
}
~Stack()
{
if(_pData != NULL)
{
delete _pData;
_pData = NULL;
_size = 0;
_capacity = 0;
cout<<this<<endl;
}
}
private:
void CheckCapacity()
{
// 申请新空间
// 拷贝元素到新空间
//memcpy() 优点:快 缺点:浅拷贝
//for() 优点:避免了浅拷贝 缺点:速度慢
// 类型萃取
// 释放旧空间
if(_size >= _capacity)
{
size_t capacity = _capacity + 3;
T* pTemp = new T[capacity];
Copy(pTemp, _pData, sizeof(T)*Size());
delete[] _pData;
_pData = pTemp;
_capacity = capacity;
}
}
private:
T* _pData;
size_t _size;
size_t _capacity;
};
void FunTest()
{
Stack<int> s1;
Stack<double> s3;
Stack<int> s4;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
s1.Push(5);
s1.Pop();
s1.Pop();
s1.Top();
Stack<int> s2(s1);
s4 = s1;
s3.Push('1.0f');
s3.Push('2.0f');
s3.Push('3.0f');
s3.Push('4.0f');
s3.Push('5.0f');
s3.Pop();
s3.Pop();
s3.Top();
}
int main()
{
FunTest();
system("pause");
return 0;
}
栈的基本操作
最新推荐文章于 2023-08-27 16:05:45 发布