// 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,int numElts> class array {
	public:
		// default constructor
		array();
		// constructor initializes elements to given value
		array(const eltType &);
		// constructor initializes from a standard array
		array(const eltType []);
		// copy constructor
		array(const array<eltType,numElts> &);
		// destructor
		~array();
		// append element to array
		array<eltType,numElts> &operator+=(eltType);
		// inspector for size of the list
		int size() const { return items; }
		// assignment operator
		array<eltType,numElts> &operator=(const array<eltType,numElts> &);
		// inspector for element of a constant list
		const eltType& operator[](int) const;
		// inspector for element of a nonconstant list
		eltType& operator[](int);
	private:
		// data members
		eltType *elements;// pointer to list elements
		int items; // size of list
};

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

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

// constructor initializes from a standard array
template <class eltType,int numElts>
	array<eltType,numElts>::array(const eltType right[]) 
{	items = numElts;			// Can it be items=right.items?; 
	elements = new eltType [items];
	assert(elements);
	for (int i = 0; i < items; ++i) {
		elements[i] = right[i];
	}
}

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

// destructor
template <class eltType,int numElts> array<eltType,numElts>::~array() 
{	delete [] elements;
}

// Append element to array
template <class eltType,int numElts> 
	array<eltType,numElts> &array<eltType,numElts>::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,int numElts>
array<eltType,numElts>& array<eltType,numElts>::
							operator=(const array<eltType,numElts> &right) 
{	if (this != &right) {
		if (size() != right.size()) {
			delete [] elements;
			items = right.size();
			elements = new eltType [right.size()];
			assert(elements);
		}
		for (int i = 0; i < right.size(); ++i)
			elements[i] = right[i];
	}
	return *this;
}

// inspector of the value of an individual element
template <class eltType,int numElts>
			const eltType& array<eltType,numElts>::operator[](int i) const 
{	assert((i >= 0) && (i < size()));
	// uncomment to see when called
	cerr << "r ";	
	return elements[i];
}

// inspector/mutator facilitator of individual element
template <class eltType,int numElts>
			eltType& array<eltType,numElts>::operator[](int i) 
{	assert((i >= 0) && (i < size()));
	// uncomment to see when called
	cerr << "l ";
	return elements[i];
}

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

#endif