Zadatak klasa

#include<iostream>
using namespace std;

class NedozvoljenaOperacija : public exception {
	int linijaKoda;
public:
	NedozvoljenaOperacija(const char * poruka, int lin):exception(poruka), linijaKoda(lin){
	}
	void ErrorInfo() {
		cout << "Error: " << exception::what() << endl;
		cout << "Linija koda: " << linijaKoda << endl;
	}
};

char * AlocirajNizKaraktera(const char * sadrzaj) {
	if (sadrzaj == nullptr)
		return nullptr;

	int vel = strlen(sadrzaj) + 1;
	char * temp = new char[vel];
	strcpy_s(temp, vel, sadrzaj);

	return temp;
}

template<class T>
class Kolekcija
{
	T* _elementi;
	int _trenutno;
public:
	//Kolekciju dopuniti u skladu sa potrebama zadatka
	Kolekcija()
	{
		_elementi = nullptr;
		_trenutno = 0;
	}
	~Kolekcija()
	{
		delete[] _elementi;
		_elementi = nullptr;
	}

	void AddElement(const T& el)
	{
		T* temp = new T[_trenutno + 1];
		for (int i = 0; i < _trenutno; i++)
		{
			temp[i] = _elementi[i];
		}

		delete[] _elementi;
		_elementi = temp;

		_elementi[_trenutno++] = el;
	}

	int GetTrenutno()const { return _trenutno; }

	T& operator[](int index)
	{
		if (index < 0 || index >= _trenutno)
			throw NedozvoljenaOperacija("Index nije validan", __LINE__);
		return _elementi[index];
	}

	friend ostream& operator<<(ostream&, const Kolekcija&);
};

template<class T>
ostream& operator<<(ostream& cout, const Kolekcija<T>& kol)
{
	for (int i = 0; i < kol._trenutno; i++)
	{
		cout << kol._elementi[i] << endl;
	}

	return cout;
}

//Kataloška prodaja
class Proizvod{
protected:
	char _sifra[10];
	char* _naziv;
	double _cijena;
	double _popust; //Izrazen procentualno
	//Dostupno proizvoda
	int _kolicina;
public:
	//Konstruktor i destruktor funkcije
	Proizvod(const char* sifra="00", const char* naziv="no_value", double cijena = 0, int kolicina= 0 )
	{
		//U slučaju nedozvoljenih vrijednosti za cijenu, popust i količinu baciti izuzetak
		if (cijena < 0 || naziv == nullptr || kolicina < 0)
			throw NedozvoljenaOperacija("Greska u validaciji podataka", __LINE__);
		strncpy_s(_sifra, sifra, _TRUNCATE);

		_naziv = AlocirajNizKaraktera(naziv);

		_cijena = cijena;
		_kolicina = kolicina;
		_popust = 0;
	}
	Proizvod(Proizvod &p) {
		/*if (p._cijena < 0 || p._naziv == nullptr || p._kolicina < 0)
			throw NedozvoljenaOperacija("Greska u validaciji podataka", __LINE__);*/

		strncpy_s(_sifra, p._sifra, _TRUNCATE);

		_naziv = AlocirajNizKaraktera(p._naziv);

		_cijena = p._cijena;
		_kolicina = p._kolicina;
		_popust = p._popust;
	}
	Proizvod &operator=(Proizvod &p) {
		if (p._cijena < 0 || p._naziv == nullptr || p._kolicina < 0)
			throw NedozvoljenaOperacija("Greska u validaciji podataka", __LINE__);
		strncpy_s(_sifra, p._sifra, _TRUNCATE);

		_naziv = AlocirajNizKaraktera(p._naziv);

		_cijena = p._cijena;
		_kolicina = p._kolicina;
		_popust = p._popust;
		return *this;
	}
	bool operator==(Proizvod p) {
		return strcmp(_sifra, p._sifra) == 0;
	}
	~Proizvod()
	{
		delete[] _naziv;
		_naziv = nullptr;
	}
	virtual void Info() {
		cout << "Sifra: " << _sifra << endl;
		cout << "Naziv: " << _naziv << endl;
		cout << "Cijena: " << _cijena << endl;
		if (_popust == 0)
			cout << "Zao nam je ali nema popusta." << endl;
		else
			cout << "Popust: " << _popust << endl;
		cout << "Kolicina: " << _kolicina << endl;
	}
	//Implementirati potrebne funkcije za rad sa klasom
};

//Implementirati nasljeđivanje
class Odjeca : public Proizvod
{
	Kolekcija<char*> _velicine;
	Kolekcija<char*> _boje;
	char _kategorija[50];
public:
	Odjeca(const char* sifra, const char* naziv, double cijena, int kolicina, const char *kategorija) :
		Proizvod(sifra, naziv, cijena, kolicina)
	{
		strncpy_s(_kategorija, kategorija, _TRUNCATE);
	}
	Odjeca(Odjeca &o): Proizvod (o)
	{
		char * tempVelicina= nullptr;
		char * tempBoja = nullptr;
		strncpy_s(_kategorija, o._kategorija, _TRUNCATE);
		for (int i = 0; i < o._velicine.GetTrenutno(); i++)
		{
			tempVelicina = AlocirajNizKaraktera(o._velicine[i]);
			if (tempVelicina == nullptr)
				throw NedozvoljenaOperacija("Nema podataka", __LINE__);
			_velicine.AddElement(tempVelicina);
		}
		for (int i = 0; i < _boje.GetTrenutno(); i++)
		{
			tempBoja = AlocirajNizKaraktera(o._velicine[i]);
			if (tempBoja == nullptr)
				throw NedozvoljenaOperacija("Nema podataka", __LINE__);
			_velicine.AddElement(tempBoja);
		}
	}
	Odjeca &operator= (Odjeca &o) {
		(Proizvod&)(*this) = o;
		char * tempVelicina = nullptr;
		char * tempBoja = nullptr;
		strncpy_s(_kategorija, o._kategorija, _TRUNCATE);
		for (int i = 0; i < o._velicine.GetTrenutno(); i++)
		{
			tempVelicina = AlocirajNizKaraktera(o._velicine[i]);
			if (tempVelicina == nullptr)
				throw NedozvoljenaOperacija("Nema podataka", __LINE__);
			_velicine.AddElement(tempVelicina);
		}
		for (int i = 0; i < _boje.GetTrenutno(); i++)
		{
			tempBoja = AlocirajNizKaraktera(o._velicine[i]);
			if (tempBoja == nullptr)
				throw NedozvoljenaOperacija("Nema podataka", __LINE__);
			_velicine.AddElement(tempBoja);
		}

	}
	//Potrebne konstruktor i destruktor funkcije
	~Odjeca()
	{
		for (int i = 0; i < _velicine.GetTrenutno(); i++)
		{
			delete _velicine[i];
		}
		for (int i = 0; i < _boje.GetTrenutno(); i++)
		{
			delete _boje[i];
		}
	}
	//Implementirati potrebne funkcije za rad sa klasom
	void AddVelicine(const char *element) {
		_velicine.AddElement(AlocirajNizKaraktera(element));
	}
	void AddBoje(const char *element) {
		_velicine.AddElement(AlocirajNizKaraktera(element));
	}
};

class Katalog
{
	char* _naslov;
	char* _vrijediDo; //Datum u formatu dd.MM.yyyy
	Kolekcija<Proizvod*> _proizvodi;
public:
	//Potrebne konstruktor i destruktor funkcije
	bool DaLiJeBroj(const char broj) {
		if (isdigit(broj))
			return true;
		return false;
	}
	Katalog(const char* naslov, const char* vrijediDo)
	{
		/*for (size_t i = 0; i < strlen(vrijediDo); i++)
		{
			if (_vrijediDo[i] != '.' && !DaLiJeBroj(_vrijediDo[i]))
				throw NedozvoljenaOperacija("Nije ispravan datum", __LINE__);
		}*/
		//U slučaju da datum ne ispunjava zadati format baciti izuzetak
		_naslov = AlocirajNizKaraktera(naslov);
		_vrijediDo = AlocirajNizKaraktera(vrijediDo);
	}

	~Katalog()
	{
		delete[] _naslov;
		_naslov = nullptr;

		delete[] _vrijediDo;
		_vrijediDo = nullptr;

		for (size_t i = 0; i < _proizvodi.GetTrenutno(); i++)
		{
			delete _proizvodi[i];
			_proizvodi[i] = nullptr;
		}
	}
	bool DodajProizvode(Proizvod &p) {
		for (int i = 0; i < _proizvodi.GetTrenutno(); i++)
		{
			if (p == *_proizvodi[i])
				throw NedozvoljenaOperacija("Proizvodi imaju isti naziv", __LINE__);

		}
		Odjeca * pok = dynamic_cast<Odjeca*>(&p);
		if (pok != nullptr)
			_proizvodi.AddElement(new Odjeca(*pok));
		else
			_proizvodi.AddElement(new Proizvod(p));
	}
	//Kreirati funkciju za dodavanje proizvoda u katalog i pri tome provjeriti da li se radi
	//o objektu izvedene ili osnovne klase.
	//Onemogućiti dodavanje identičnih proizvoda u jedan katalog (proizvode razlikovati samo na osnovu šifre).
	//U slučaju pokušaja dodavanja istih proizvoda baciti izuzetak.

	//Funkciju za uklanjanje proizvoda iz kataloga na osnovu šifre.
	//Ukoliko se ne pronađe traženi proizvod baciti izuzetak.

	//Preklopiti operator za ispis kataloške ponude
};

class Narudzba
{
	int _broj;
	char* _datumIsporuke; //Datum u formatu dd.MM.yyyy
	Kolekcija<Proizvod*> _naruceniProizvodi;
	bool otkazana;
public:
	//Potrebne konstruktor i destruktor funkcije
	//U slučaju da datum ne ispunjava zadati format baciti izuzetak.

	//Kreirati funkciju za dodavanje proizvoda narudžbe sa povratnom vrijednošću tipa bool.
	//Ukoliko proizvod više nije dostupan baciti izuzetak.
	//Dozvoliti dodavanje istog proizvoda više puta.

	//Funkciju za uklanjanje određenog proizvoda iz narudžbe. Voditi računa da narudžba može
	//imati više puta isti proizvod.

	//Dodati funkciju za proračun ukupne cijene narudžbe.
	//Voditi računa o mogućnosti dodavanja više istih proizvoda (količina).
	//Uračunati popust u slučaju da je definisan.

	//Preklopiti operator za ispis podataka o narudžbi zajedno sa cijenom.
};

//U posljednjoj klasi samostalno prepoznati izuzetne situacije
class Prodavac
{
	char* _imePrezime;
	Kolekcija<Narudzba>* _narudzbe;
public:
	//Potrebne konstruktor i destruktor funkcije

	//Omogućiti dodavanje narudžbi za prodavača

	//Omogućiti otkazivanje narudžbe na osnovu njenog broja.

	//Ispis svih podataka o prodavaču i kratke informacije o
	//svim narudžbama (datum, broj proizvoda i cijena). Posebno izdvojiti otkazane narudžbe.

	//Implementirati metodu koja u svim aktivnim narudžbama pronalazi proizvod koji se najviše prodavao
	//sa informacijom o tome da li se radi o odjeći ili osnovnom proizvodu.

};

int main()
{
	//Dodati minimalno 5 proizvoda u katalog.
	//Ispisati ponudu kupcu
	//Omogućiti kreiranje narudžbe za jednog prodavača na osnovu izbora kupca.
	Proizvod p("123", "Cigare", 10, 10);
	Proizvod p1("123", "Cigare", 10, 10);
	Katalog k("Gloria", "12.1.2019");
	try
	{

	}
	catch (NedozvoljenaOperacija &n)
	{
		n.ErrorInfo();
	}



	system("pause");
	return 0;
}