StackVector

#include <array>
#include <stdexcept>

template <typename T, size_t N>
class StackVector {
public:
    explicit StackVector(size_t a_size = 0)
        :size_array_(a_size)
    {
        if (a_size > N) {
            throw std::invalid_argument("Error: capacity exceeded");
        }
    }

    T& operator[](size_t index) {
        return stackvector_.at(index);
    }

    const T& operator[](size_t index) const {
        return stackvector_.at(index);
    }

    auto begin() {
        return stackvector_.begin();
    }

    auto end() {
        return stackvector_.begin() + size_array_;
    }

    auto begin() const {
        return stackvector_.begin();
    }

    auto end() const {
        return stackvector_.begin() + size_array_;
    }

    size_t Size() const {
        return size_array_;
    }

    size_t Capacity() const {
        return N;
    }

    void PushBack(const T& value) {
        if (size_array_ == N) {
            throw std::overflow_error("Error: capacity is equal to the maximum size");
        }
        stackvector_[size_array_] = value;
        ++size_array_;
    }

    T PopBack() {
        if (size_array_ == 0) {
            throw std::underflow_error("Error: vector is empty");
        }
        T value = stackvector_[size_array_ - 1];
        --size_array_;
        return value;
    }

private:
    size_t size_array_;
    std::array <T, N> stackvector_;
};