#include <assert.h>

class Array {
private:
	int _size;
	int _current;
	int _stacksize;
	void** _data;
public:
	Array() {
		_size = 0;
		_current = 0;
		_stacksize = 0;
	}

	Array(Array* oa) {
		_size = 0;
		_current = 0;
		_stacksize = 0;
		void* telem;
		int tc = oa->pos();
		oa->reset();

		while ( (telem = oa->next()) ) {
			push(telem);
		}

		oa->setPos(tc);

	}

	void setPos(int np) {
		_current = np;
	}

	int pos() {
		return _current;
	}

	int length() {
		return _size;
	}

	void reset() {
		_current = 0;
	}

	void* current() {
		if ( _current < _size ) {
			return _data[_current];
		} else {
			return 0;
		}
	}

	void* next() {
		if ( _current < _size ) {
			_current++;
			return _data[_current-1];
		} else {
			return 0;
		}
	}

	void push(void* elem) {
		if ( _size >= _stacksize ) {
			_stacksize = _stacksize + 3;
			void** tdat = new void*[_stacksize];

			for ( int i = 0; i < _size; i++ ) {
				tdat[i] = _data[i];
			}

			if ( _size > 0 ) {
				delete[] _data;
			}
			_data = tdat;
		}

		_data[_size] = elem;
		_size++;
	}

	void* pop() {
		_size--;
		if ( _current == _size ) {
			_current = _size-1;
		}
		return _data[_size];
	}

	void* get(int p) {
		assert(p>=0);
		assert(p<_size);
		return _data[p];
	}

	void set(int p, void* ne) {
		assert(p>=0);
		assert(p<_size);
		_data[p] = ne;
	}

	void clear() {
		_size = 0;
		_current = 0;
		_stacksize = 0;
		delete[] _data;
	}

	void operator+=(void* ne) {
		push(ne);
	}

	void*& operator[](int p) {
		assert(p>=0);
		assert(p<_size);
		return _data[p];
	}

	~Array() {
		delete[] _data;
	}
};