// File: Array.h
// Template array class definition and implementation
// Written by Daniel Spiegel

#ifndef ARRAY_H
#define ARRAY_H

#include <iostream>
#include <assert.h>

using namespace std;

template <class eltType> class Array {
	public:
		// default constructor
		Array(int n = 10);
		// constructor initializes elements to given value
		Array(int n, const eltType &val);
		// constructor initializes from a standard array
		Array(const eltType A[], int n);
		// copy constructor
		Array(const Array<eltType> &A);
		// destructor
		~Array();
		// append element to array
		Array<eltType> &operator+=(eltType);
		// inspector for size of the list
		int size() const { return items; }
		// assignment operator
		Array<eltType> &operator=(const Array<eltType> &A);
		// inspector for element of a constant list
		const eltType& operator[](int i) const;
		// inspector for element of a nonconstant list
		eltType& operator[](int i);
	private:
		// data members
		eltType *elements;// pointer to list elements
		int items; // size of list
};

// default constructor
template <class eltType> Array<eltType>::Array(int n) {
	assert(n > 0);
	items = n;
	elements = new eltType [n];
	assert(elements);
}

// constructor initializes elements to given value
template <class eltType>
Array<eltType>::Array(int n, const eltType &val) {
	assert(n > 0);
	items = n;
	elements = new eltType [n];
	assert(elements);
	for (int i = 0; i < n; ++i) {
		elements[i] = val;
	}
}

// constructor initializes from a standard array
template <class eltType>
Array<eltType>::Array(const eltType A[], int n) {
	assert(n > 0);
	items = n;
	elements = new eltType [n];
	assert(elements);
	for (int i = 0; i < n; ++i) {
		elements[i] = A[i];
	}
}

// copy constructor
template <class eltType> Array<eltType>::Array(const Array<eltType> &A) {
	items = A.size();
	elements = new eltType [A.size()];
	assert(elements);
	for (int i = 0; i < A.size(); ++i)
		elements[i] = A[i];
}

// destructor
template <class eltType> Array<eltType>::~Array() {
	delete [] elements;
}

// Append element to array
template <class eltType> Array<eltType> &Array<eltType>::operator+=(eltType elt) {
	eltType *temp=new eltType[items+1];
	for (int i = 0; i < size(); ++i)
		temp[i]=elements[i];
	temp[items++]=elt;
	delete [] elements;
	elements=temp;
	return(*this);
}

// assignment
template <class eltType>
Array<eltType>& Array<eltType>::operator=(const Array<eltType> &A) {
	if (this != &A) {
		if (size() != A.size()) {
			delete [] elements;
			items = A.size();
			elements = new eltType [A.size()];
			assert(elements);
		}
		for (int i = 0; i < A.size(); ++i)
			elements[i] = A[i];
	}
	return *this;
}

// inspector of the value of an individual element
template <class eltType>
const eltType& Array<eltType>::operator[](int i) const {
	assert((i >= 0) && (i < size()));
	return elements[i];
}

// inspector/mutator facilitator of individual element
template <class eltType>
eltType& Array<eltType>::operator[](int i) {
	assert((i >= 0) && (i < size()));
	return elements[i];
}

// template insertion operator for Array
template <class eltType>
ostream& operator<<(ostream &sout, const Array<eltType> &A){
	sout << "[ ";
	for (int i = 0; i < A.size(); ++i)
		sout << A[i] << " ";
	sout << "]";
	return sout;
}

// insertion operator for Array<char>
ostream& operator<<(ostream &sout,const Array<char> &A) {
	for (int i = 0; i < A.size(); ++i)
		sout << A[i];
	return sout;
}


#endif