template<class T>
class Store{
    private:
        T item; //item用于存放任意类型的数据
        bool haveValue; //标记item是否已经被存入内容
    public:
        T &getElem(); //提取数据
        void putElem(const T& x); //存入数据
        Store();
};

template<class T>
Store<T>::Store():haveValue(false){ }

template<class T>
T& Store<T>::getElem(){
    if(!haveValue){
        cout<<"no data!"<<endl;
        exit(1); //使程序完全退出，返回操作系统
    }
    return item;
}

template<class T>
void Store<T>::putElem(const T& x){
    item = x;
    haveValue = true;
}

struct student{
    int id;
    float gpa;
};
int main(){
    Store<int>s1;
    s1.putElem(4);
    cout<<s1.getElem()<<endl;
    student s= {1001,98.2};
    Store<student> s2;
    s2.putElem(s);
    cout<<s2.getElem().id<<" "<<s2.getElem().gpa<<endl; 
}

template <class T>
class Array
{
private:
    T *list;  //T类型指针，存放动态分配的数组首地址
    int size; //数组大小
public:
    Array(int sz = 50);
    Array(const Array<T> &a); //复制构造
    ~Array();
    Array<T> &operator=(const Array<T> &rhs);
    T &operator[](int i);             //重载下标运算符 可被改变 a[3] = 5
    const T &operator[](int i) const; //重载下标运算符 常函数
    operator T *();                   //重载隐式转换，将对象重载为T*类型
    operator const T *() const;
    int getSize() const; //获取数组大小
    void reSize(int sz); //修改数组大小
};
//构造函数
template <class T>
Array<T>::Array(int sz)
{
    assert(sz >= 0);
    size = sz;
    list = new T[size]; //动态分配数组空间
}
//拷贝构造（深层复制）
template <class T>
Array<T>::Array(const Array<T> &a)
{
    size = a.size;
    list = new T[size];
    for (int i = 0; i < size; i++)
        list[i] = a.list[i];
}
//析构函数
template <class T>
Array<T>::~Array()
{
    delete[] list;
}
//重载=
template <class T>
Array<T> &Array<T>::operator=(const Array<T> &rhs)
{
    if (this != &rhs)
    { //避免自身复制
        if (size != rhs.size)
        { //如果两个数组的大小不同，则需要重新分配内存空间
            delete[] list;
            size = rhs.size;
            list = new T[size];
        }
        for (int i = 0; i < size; i++)
            list[i] = rhs.list[i];
    }
    return *this; //返回当前对象的引用
}
//重载下标运算符[ ]，实现与普通数组一样通过下标访问元素，具有越界检查功能 
template <class T>
T &Array<T>::operator[](int i)
{
    assert(i >= 0 && i < size);
    return list[i];
    //return *(list+i);
}
//重载[ ]常函数
template <class T>
const T &Array<T>::operator[](int i) const
{
    assert(i >= 0 && i < size);
    return list[i];
    //return *(list+i);
}
//重载到T*类型的转换
template <class T>
Array<T>::operator T *()
{
    return list; //返回当前对象私有数组的首地址
}
//重载到T*类型的转换 常函数
template <class T>
Array<T>::operator const T *() const
{
    return list;
}
template <class T>
int Array<T>::getSize() const
{
    return size;
}
template <class T>
void Array<T>::reSize(int sz)
{
    assert(sz >= 0);
    if (sz == size)
        return;
    T *newlist = new T[sz];          //申请新的数组内存
    int n = (sz < size ? sz : size); //将较小值赋给n
    for (int i = 0; i < n; i++)
        newlist[i] = list[i];
    delete[] list;  //删除原数组
    list = newlist; //使list指向新数组
    size = sz;      //更新size
}