class Niz
{
public:
	//	konstruktor niza date velicine
	Niz ( int n=0 )
		: _Velicina(0),
		  _Alocirano(0),
		  Elementi(0)
		{ PromeniVelicinu(n); }
		
	//	destruktor
	~Niz()
		{ delete [] Elementi; }
		
	//	konstruktor kopije
	Niz( const Niz& a )
		{ init(a); }
		
	//	operator dodeljivanja
	Niz& operator = ( const Niz& a )
		{
		if( this != &a ){
			delete [] Elementi;
			init(a);			
			}
		return *this;
		}

	//	izracunavanje velicine niza
	int Velicina() const
		{ return _Velicina; }

	//	pristupanje elementima nekonstantnih nizova
	//	kako za citanje tako i za menjanje
	int& operator[] ( int n )
		{ 
		if( n >= Velicina() )
			PromeniVelicinu( n+1 );
		return Elementi[n]; 
		}

	//	pristupanje elementima konstantnih nizova
	//	samo za citanje
	int operator[] ( int n ) const
		{ return Elementi[n]; }

	//	dodavanje novog elementa niza na kraj
	void DodajNaKraj( int x )
		{ 
		PromeniVelicinu( Velicina() + 1 );
		Elementi[Velicina() - 1] = x; 
		}
	//	brisanje poslednjeg elementa niza
	void ObrisiPoslednji()
		{ PromeniVelicinu( Velicina() - 1 ); }
	//	vrednost poslednjeg elementa niza
	int Poslednji() const
		{ return Elementi[Velicina()-1]; }

	void PromeniVelicinu( int novaVelicina )
		{
		// povecavanje
		if( novaVelicina > _Alocirano ){
			//	izracunavamo najmanju velicinu 
			//	oblika 10*2^k
			//	koja je >= novaVelicina
			if( _Alocirano < 10 )
				_Alocirano = 10;
			while( _Alocirano < novaVelicina )
				_Alocirano *= 2;
			//	alokacija i konstrukcija podrazumevanim konstruktorom
			int* noviElementi = new int[_Alocirano];
			//	kopiranje elemenata
			for( int i=0; i<_Velicina; i++ )
				noviElementi[i] = Elementi[i];
			//	brisanje starih elemenata
			delete [] Elementi;
			//	postavljanje novih elemenata 
			Elementi = noviElementi;
			}
		
		// za sada ne smanjujemo alociran prostor
		
		//	promena velicine
		_Velicina = novaVelicina; 
		}
	
private:
	//	inicijalizacija kopije
	void init( const Niz& a )
		{
		//	alociramo tacno koliko nam je potrebno
		_Alocirano = _Velicina = a._Velicina;
		if( _Velicina > 0 ){
			//	alokacija i konstrukcija podrazumevanim konstruktorom
			Elementi = new int[_Velicina];
			//	kopiranje elemenata
			for( int i=0; i<_Velicina; i++ )
				Elementi[i] = a.Elementi[i];
			}
		else
			Elementi = 0;
		}

	//	pokazivac na alociran prostor za elemente
	int* Elementi;
	//	velicina koju vidi korisnik
	int _Velicina;
	//	velicina obezbedjenog prostora
	int _Alocirano;
};