// Vector.h
//
// A class Vector similar to the STL container vector.
// Version 1.0
//
// Included in this version:
//   Vector(), Vector(n), Vector(init_list)
//   size(), indexing operator

#ifndef _Vector_h_
#define _Vector_h_

#include <algorithm>
#include <initializer_list>

template <class T>
class Vector
{
public:
    Vector() : buffer_(nullptr), size_(0) {}
    explicit Vector(int n);
    Vector(const std::initializer_list<T> & init_list);

    int size() const { return size_; }

    T & operator[](int i) { return buffer_[i]; }
    const T & operator[](int i) const { return buffer_[i]; }

private:
    T * buffer_;
        // points to a dynamically allocated array that
        // contains the vector elements
    int size_;
        // the number of elements in the vector (and the size of
        // the buffer)

    // Returns pointer to new buffer of size n.  Returns
    // nullptr if n == 0.
    T * get_new_buffer(int n) const;
};

template <class T>
inline T * Vector<T>::get_new_buffer(int n) const
{
    return (n == 0 ? nullptr : new T[n]());
}

template <class T>
inline Vector<T>::Vector(int n)
{
    buffer_ = get_new_buffer(n);
    size_ = n;
}

template <class T>
inline Vector<T>::Vector(const std::initializer_list<T> & init_list)
{
    buffer_ = get_new_buffer(init_list.size());
    std::copy(init_list.begin(), init_list.end(), buffer_);
    size_ = init_list.size();
}

#endif