#ifndef zap_ukH
#define zap_ukH
// ukazatel spojený s alokací prostoru pomocí new, ci new [] ve volání
// odkazy bez new se řesí klasickými ukazateli
// vkládání ukazatele musí být spojeno s new !!!
// není potřeba explicitně dealokovat, a funguje s výjimkami, jinak je potřeba
// se k němu chovat jako k normálnímu ukazateli
// pro uvolneni pameti nepouzivejte delete param, ale funkci Destroy(param)

// volání Zapuk<Typ_ukazatele> nazev_proměnne(new Typ_ukazatele)
// Zapuk<double> ukazatel(new double)

// sablona pro ukazatel na jeden prvek
// objekt je vlastníkem ukazatele - odalokovává pamět při konci zivota objektu, nebo při zapsání nového ukazatele
// v případě vlození nového ukazatele je původní pamět odalokována
template <typename T>
class Zapuk {
	T * uk;
	Zapuk(Zapuk<T>&) {} // nutno zakázat - musí být spojeno s alokací
	Zapuk& operator = (const Zapuk&) {} // musí být také spojeno s alokací
public:
	Zapuk(T *puk) { uk = puk; }
	Zapuk& operator = (T* aUk) 
	{	if (uk == aUk) return *this;
		if (uk != nullptr) delete uk; 
	uk = aUk;  return *this; }
	~Zapuk(void) { Destroy(); }
	operator T* (void) { return uk; }
	void Destroy() { if (uk) delete uk; uk = nullptr; }
	//static void operator delete (void *uk) {}
};



// volání Zapuk<Typ_ukazatele []> nazev_proměnne(new Typ_ukazatele[pocet_prvku])
// Zapuk<double []> ukazatel(new double[10])
// sablona pro ukazatel drzici pole
template <typename T>
class Zapuk<T[]> {
	T * uk;
	Zapuk(Zapuk<T[]>&) {}
	Zapuk& operator = (const Zapuk&) {} // musí být také spojeno s alokací
public:
	Zapuk& operator = (T *aUk) {
		if (uk == aUk) return *this;
		if (uk != nullptr) delete[] uk; 
		uk = aUk; return *this; }
	Zapuk(T *puk) { uk = puk; }
	~Zapuk(void) { Destroy(); }
	operator T* (void) { return uk; }
	void Destroy() { if (uk) delete[] uk; uk = nullptr; }
	//static void operator delete[] (void *uk) {}
};

// funkce pro odalokování paměti volající destruktor, určená pro
// explicitní destrukci paměti zapouzdřeného ukazatele
template <typename R>
inline void Destroy(R &tt) { tt.Destroy(); }



#endif



// void Test(Zapuk<double[]> tst) {}
void Testref(Zapuk<double[]> &tst) {}

int main(int argc, char* argv[])
{
	{
		Zapuk<double[]> ukazatel(new double[10]);
		Zapuk<int *[]> ukazateli(new int*[10]);
		Zapuk<int *> ukazatelii(new int*);
		// Test (ukazatel); // nelze zalozit kopie prvku jako kopy konstruktor
		Testref(ukazatel);
		*ukazatel = 5;
		*(ukazateli + 5) = 0;
		ukazateli = new int*[20]; // puvodni pamet se odalokuje, nova se ulozi, nekopiruje hodnoty
		Destroy(ukazatelii);
		// ukazatelii.~Zapuk<int *>();			
		// delete[] ukazateli; // odalokuje "vnitřní" ukazatel díky konverznímu operátoru		
		// lépe  napsat a pouzívat funkci Destroy - protoze hodnota zustane
		// a v dalsim radku se odalokuje podruhe
		ukazateli = nullptr; // tohle nastaví "vnitřní" ukazatel na nullptr
		double b;
		b = *ukazatel;
		ukazatel[0] = 4;
		b = ukazatel[0];
	}
	return 0;
}