ispitni2017

#include <iostream>
using namespace std;
/****************************************************************************
1. SVE KLASE TREBAJU POSJEDOVATI ADEKVATAN DESTRUKTOR
2. NAMJERNO IZOSTAVLJANJE KOMPLETNIH I/ILI POJEDINIH DIJELOVA DESTRUKTORA KOJI UZROKUJU
RUNTIME ERROR CE BITI OZNACENO KAO "RE"
3. SPAŠAVAJTE PROJEKAT KAKO BI SE SPRIJECILO GUBLJENJE URAÐENOG ZADATKA
4. NAZIVI FUNKCIJA, TE BROJ I TIP PARAMETARA MORAJU BITI IDENTICNI ONIMA KOJI SU KORIŠTENI U
TESTNOM CODE-U, OSIM U SLUCAJU DA POSTOJI ADEKVATAN RAZLOG ZA NJIHOVU MODIFIKACIJU. OSTALE,
POMOCNE FUNKCIJE MOŽETE IMENOVATI I DODAVATI PO ŽELJI.
5. BEZ OBZIRA NA TO DA LI SU ISPITNI ZADACI URAÐENI, SVI STUDENTI KOJI SU PRISTUPILI ISPITU
MORAJU PREDATI SVOJ RAD
6. ZA POTREBE TESTIRANJA, UNUTAR MAIN FUNKCIJE MOZETE DODAVATI NOVE TESTNE PODATKE
****************************************************************************/
//narednu liniju code-a ignorisite, osim u slucaju da vam bude predstavljala smetnje u radu
#pragma warning(disable:4996)
const char * crt = "\n----------------------------------------------------\n";
class Datum {
	int * _dan, *_mjesec, *_godina;
public:
	Datum(int d = 0, int m = 0, int g= 0) {
		_dan = new int(d);
		_mjesec = new int(m);
		_godina = new int(g);
	}
	~Datum() {
		delete _dan; _dan = nullptr;
		delete _mjesec; _mjesec = nullptr;
		delete _godina; _godina = nullptr;
	}
	Datum& operator=(const Datum &d) {
		_dan = new int(*d._dan);
		_mjesec = new int(*d._mjesec);
		_godina = new int(*d._godina);

		return *this;
	}
	Datum(const Datum&d) {
		_dan = new int(*d._dan);
		_mjesec = new int(*d._mjesec);
		_godina = new int(*d._godina);
	}
	friend ostream & operator<<(ostream & COUT, Datum obj) {
		COUT << *obj._dan << "/" << *obj._mjesec << "/" << *obj._godina<<"   ";
		return COUT;
	}
};
template<class T, int velicina>
class FITArray {
	T _niz[velicina];
	int _trenutno;
	bool _dozvoliDupliciranje;
public:
	//OSTALE FUNKCIJE CLANICE DEFINISATI VAN TEMPLATE KLASE
	FITArray(bool dozvoliDupliciranje = true);
	FITArray(const FITArray &fit);
	int GetTrenutno();
//Trajanje: 120 minFakultet Informacijskih tehnologija
	T GetObjekat(int index) {
		return _niz[index];
	}
	T * GetNiz() { return _niz; }
	bool operator += (T element);

	FITArray<T, velicina> operator()(const int &a, const int &b);
	bool operator -=(T element);
	friend ostream& operator<< <>(ostream &, const FITArray &);
};
template<class T, int velicina>
FITArray<T, velicina>::FITArray(bool dozvoliDupliciranje) {
	_dozvoliDupliciranje =
		dozvoliDupliciranje; _trenutno = 0;
}
template<class T, int velicina>
int FITArray<T, velicina>::GetTrenutno() {
	return _trenutno;
}
template<class T, int velicina>
//jeeeeeeeeeeeeeeeeeeeeeeeeees
bool FITArray<T, velicina>::operator += (T element) {
	for (int i = 0; i < _trenutno; i++)
	{
		if (_niz[i] == element && _dozvoliDupliciranje == false) {
			return false;
		}
	}
	_niz[_trenutno++] = element;
	return true;
}
template<class T, int velicina>
ostream & operator <<(ostream &cout, const FITArray<T, velicina> &fit) {
	if (fit._trenutno == 0)
		cout << "Nema elemenata u nizu " << endl;
	for (int i = 0; i < fit._trenutno; i++)
	{
		cout << fit._niz[i] << "   ";
	}
	return cout;
}
template<class T, int velicina>
bool FITArray<T, velicina>::operator -=(T element) {
	int c = 0 ;
	for (int i = 0; i < _trenutno; i++)
	{
		if (element != _niz[i]) {
			_niz[c++] = _niz[i];
		}
	}
	_trenutno--;
	return true;
}
template<class T, int velicina>
FITArray<T, velicina>::FITArray(const FITArray& fit) {

	_trenutno = fit._trenutno;
	_dozvoliDupliciranje = fit._dozvoliDupliciranje;
	for (int i = 0; i < _trenutno; i++)
	{
		_niz[i] = fit._niz[i];
	}
}
template<class T, int velicina>
FITArray<T, velicina> FITArray<T, velicina>::operator()(const int &a, const int &b) {
	FITArray<T, b- a + 1> temp(false);
	for (int i = a; i <= b; i++)
	{
		temp[i] += _niz[i];
	}
	return temp;
}
char *AlocirajNizKaraktera(const char *sadrzaj) {
	if (sadrzaj == nullptr)
		return nullptr;
	int size = strlen(sadrzaj) + 1;
	char *temp = new char[size];
	strcpy_s(temp, size, sadrzaj);
	return temp;
}
class PolozeniPredmet {
	char * _naziv;
	int _ocjena;
	Datum _datumPolaganja;
public:
	PolozeniPredmet(Datum d = Datum(), const char *naziv= "---", int ocjena = 0) {
		_naziv = AlocirajNizKaraktera(naziv);
		_ocjena = ocjena;
		_datumPolaganja = d;
	}
	int ocjena() {
		return _ocjena;
	}

	~PolozeniPredmet() { delete[] _naziv; _naziv = nullptr; }
	friend ostream & operator<<(ostream & COUT, PolozeniPredmet * obj) {
		COUT << obj->_naziv << "(" << obj->_ocjena << ")" << obj->_datumPolaganja << endl;
		return COUT;
	}
};


class Student {
	static int _indeksCounter; //sluzi za odredjivanje narednog broja indeksa koji ce biti dodijeljen studentu,
	//pocevsi od 160000
	const int _indeks;
	char * _imePrezime;
	FITArray<PolozeniPredmet*, 40> _polozeniPredmeti;
public:
	Student(const char *imePrezime): _indeks(_indeksCounter++){
		_imePrezime = AlocirajNizKaraktera(imePrezime);
	}
	~Student() {
		delete[] _imePrezime; _imePrezime = nullptr;
	}
	bool DodajPredmet(const PolozeniPredmet & p) {
		PolozeniPredmet * temp = new PolozeniPredmet(p);
		if (_polozeniPredmeti += temp)
			return true;
		return false;
	}
	float GetProsjek() {
		float prosjek = 0;
		for (int i = 0; i < _polozeniPredmeti.GetTrenutno(); i++)
		{
			prosjek += _polozeniPredmeti.GetObjekat(i)->ocjena();
		}
		return prosjek / _polozeniPredmeti.GetTrenutno();
	}
	Student& operator =(const Student &s) {
		_imePrezime = AlocirajNizKaraktera(s._imePrezime);
		_polozeniPredmeti = s._polozeniPredmeti;
		return *this;
	}
	friend ostream & operator<<(ostream & COUT, Student & obj) {
		COUT << obj._indeks << " " << obj._imePrezime << endl << obj._polozeniPredmeti;
		return COUT;
	}

};
int Student ::_indeksCounter = 160000;
void main() {
	const int max = 20;
	Datum jucer(20, 11, 2017), danas(21, 11, 2017), sutra(22, 11, 2017);
	cout << jucer << danas << sutra << endl;
	jucer = danas;
	cout << jucer << danas << sutra << endl;
	//parametar tipa bool odredjuje da li je u nizu dozvoljeno dupliciranje elemenata
	FITArray<int, max> nizIntegera(false);
	for (size_t i = 0; i < max - 1; i++)
		nizIntegera += i;//dodaje novog clana niza
	if (!(nizIntegera += 6))//pokusavamo dodati dupli clan niza
		cout << "Element nije dodan u niz" << endl;
	cout << crt << nizIntegera << crt; //ispisuje sve clanove niza
	nizIntegera -= 9; //uklanja clan niza sa vrijednoscu 9
	nizIntegera -= 17;
	FITArray<int, max> noviNizIntegera(nizIntegera);
	cout << crt << noviNizIntegera << crt;
	/*parametri odredjuju lokacije (indekse u nizu) elemenata OD - DO koje je potrebno vratiti. u
	slucaju da u nizu ne postoji trazeni broj elemenata funkcija treba da vrati sve element od
	lokacije OD pa do posljednje dostupnog elementa */
	/*cout << "Clanovi niza od lokacije 2 do lokacije 5 su -> " << noviNizIntegera(2, 5) <<
		crt;*/
	Student adel("Adel Handzic"), jasmin("Jasmin Azemovic");
	PolozeniPredmet prII(jucer, "PRII", 8), prIII(sutra, "PRIII", 7);
	adel.DodajPredmet(prII);
	adel.DodajPredmet(prIII);
	//Fakultet Informacijskih tehnologija
	cout << adel << endl;
	//vraca prosjecnu ocjenu studenta
	cout << "Prosjecna ocjena -> " << adel.GetProsjek() << crt;
	jasmin = adel;
	cout << jasmin << endl;
	cout << "Prosjecna ocjena -> " << jasmin.GetProsjek() << crt;

	system("pause");
}