template <typename T, std::size_t N>
class Array {

    friend bool operator==(const Array& lhs, const Array& rhs) {
        return (lhs.size() == rhs.size()) && equal(lhs.begin(), lhs.end(), rhs.begin());
    }

    // using rel_ops::operator!=; // could replace this
    friend bool operator!=(const Array& lhs, const Array& rhs) {
        return !(lhs==rhs);
    }

private:

    T a[N];

public:
    Array() {}

    Array(const initializer_list<T>& rhs) {
        if (rhs.size() != 0) {
            copy(rhs.begin(), rhs.end(), begin());
        }
    }

    T& operator[](T i) {
        return a[i];
    }
    const T& operator[](T i) const {
        return (*const_cast<Array*>(this))[i];
    }

    Array& operator=(const Array& rhs) {
        if (this == &rhs){
            return *this;
        }
        if (rhs.size() != 0) {
            copy(rhs.begin(), rhs.end(), begin());
        }
        return *this;
    }

    T* begin() {
        return &a[0];
    }
    const T* begin() const {
        return const_cast<Array*>(this)->begin();
    }

    T* end() {
        return &a[N];
    }
    const T* end() const {
        return const_cast<Array*>(this)->end();
    }

    int size() const {
        return N;
    }

};