Стек для хранения данных - C++ - Ответ 3710371

#include <iostream>
#include <algorithm>
#include <stdexcept>
#include <string>
 
template<typename T>
class Vector
{
public:
    Vector() : psize(0), p(0){}
    void push_back(T const& lhs)
    {
            T* pt = static_cast<T*>(operator new[](sizeof(T) * (psize + 1)));
            for(size_t i = 0; i < psize; ++i)
            {
                new(pt + i)T(p[i]);
            }
            new(pt + psize)T(lhs);
            std::swap(p, pt);
            for(size_t i = 0; i < psize; ++i)
            {
                pt[i].~T();
            }
            operator delete[](pt);
            pt = 0;
            ++psize;
    }
    void pop_back()
    {
        if(psize)
            --psize;
    }
    T& back()
    {
        if(!psize)
        {
            throw std::out_of_range("Vector<T>::back failed");
        }
        return p[psize - 1];
    }
    void clear()
    {
        for(size_t i = 0; i < psize; ++i)
        {
            p[i].~T();
        }
        operator delete[](p);
        p = 0;
        psize = 0;
    }
    size_t size() const
    {
        return psize;
    }
    ~Vector()
    {
        for(size_t i = 0; i < psize; ++i)
        {
            p[i].~T();
        }
        operator delete[](p);
        p = 0;
        psize = 0;
    }
private:
    size_t psize;
    T* p;
    Vector(Vector const&);
    Vector& operator=(Vector);
};
 
template<typename T, typename Container = Vector<T>>
class Stack
{
public:
    void push(T const& lhs)
    {
        con.push_back(lhs);
    }
    void pop()
    {
        con.pop_back();
    }
    T& top()
    {
        return con.back();
    }
    void clear()
    {
        con.clear();
    }
    size_t size() const
    {
        return con.size();
    }
private:
    Container con;
};
 
struct Student
{
    Student(std::string const& name, std::string const& group, double const mark) :
        name_(name), group_(group), mark_(mark){}
    std::string name_, group_;
    double mark_;
};
 
std::ostream& operator<<(std::ostream& ost, Student const& st)
{
    return ost << st.name_ << '\n' << st.group_ << '\n' << st.mark_;
}
 
int main()
{
    Stack<Student> stack;
    stack.push(Student("name1", "group1", 4.56));
    stack.push(Student("name2", "group2", 3.3));
    stack.clear();
    stack.push(Student("name3", "group3", 4.09));
    stack.push(Student("name4", "group4", 3.33));
    size_t stacksize = stack.size();
    for(size_t i = 0; i < stacksize; ++i)
    {
        std::cout << "stack.size is " << stack.size() << std::endl;
        std::cout << stack.top() << std::endl;
        stack.pop();
    }
    return 0;
}