main

#include<iostream>
#include<string>
#include<conio.h>
#include<fstream>

using namespace std;

class Apartament
{
protected:
	const unsigned int id;
	string adresa;
	char proprietar[50];
	double pret;
	unsigned int numar_camera;
	float* suprafate_camere;
	static int nr_total;

public:
	//constructor fara parametri
	Apartament() :id(-1)
	{
		this->adresa = "Necunoscuta";
		strcpy(this->proprietar, "Anonim");
		this->pret = 0;
		this->numar_camera = 0;
		this->suprafate_camere = NULL;
	}

	//constructor cu toti parametri
	Apartament(unsigned int v_id, string v_adresa, char v_proprietar[50],
		double v_pret, unsigned int v_numar_camera, float *v_suprafate_camera)
		:id(nr_total++)
	{
		if (v_adresa.length() > 0)
		{
			this->adresa = v_adresa;
		}
		else {
			this->adresa = "Necunoscuta";
		}

		if (v_proprietar != NULL)
		{
			strcpy(this->proprietar, v_proprietar);
		}
		else {
			strcpy(this->proprietar, "Anonim");
		}

		this->pret = v_pret;
		this->numar_camera = v_numar_camera;
		if (v_suprafate_camera != NULL)
		{
			this->suprafate_camere = new float[this->numar_camera];
			for (int i = 0; i < this->numar_camera; i++)
			{
				this->suprafate_camere[i] = v_suprafate_camera[i];
			}
		}
	}

	//constructor de copiere
	Apartament(const Apartament& copie) : id(copie.nr_total++)
	{
		if (copie.adresa.length() > 0)
		{
			this->adresa = copie.adresa;
		}
		else {
			this->adresa = "Necunoscuta";
		}

		if (copie.proprietar != NULL)
		{
			strcpy(this->proprietar, copie.proprietar);
		}
		else {
			strcpy(this->proprietar, "Anonim");
		}

		this->pret = copie.pret;
		this->numar_camera = copie.numar_camera;
		if (copie.suprafate_camere != NULL)
		{
			this->suprafate_camere = new float[this->numar_camera];
			for (int i = 0; i < this->numar_camera; i++)
			{
				this->suprafate_camere[i] = copie.suprafate_camere[i];
			}
		}
	}

	//destructorul
	~Apartament()
	{
		if (this->suprafate_camere != NULL && this->numar_camera > 0)
		{
			delete[]this->suprafate_camere;
		}
	}

	friend ostream& operator<<(ostream & out, Apartament a)
	{
		out << "Detalii despre aparatement" << endl;
		out << "Id-ul apartamentului este:" << a.id << endl;
		out << "Adresa la care se afla este:" << a.adresa <<endl;
		out << "Numele proprietarului este:" << a.proprietar << endl;
		out << "Pretul apartaentului este:" << a.pret << endl;
		out << "Apratamentul are un numar de" << a.numar_camera << "camere." << endl;
		if (a.numar_camera > 0 && a.suprafate_camere != NULL)
		{
			for (int i = 0; i < a.numar_camera; i++)
			{
				out << "Suprafata camerei" << i + 1 << "este de" << a.suprafate_camere << "metri patrati" << endl;
			}
		}

		return out;
	}

	//Setteri
	void setAdresa(string v_adresa) {
		if (v_adresa.length() > 0) {
			this->adresa = v_adresa;
		}
	}
	void setProprietar(char v_proprietar[50]) {
		if (v_proprietar != NULL) {
			strcpy(this->proprietar, v_proprietar);
		}
		else {
			strcpy(this->proprietar, "Anonim");
		}
	}
	void setPret(double v_pret) {
		if (v_pret > 0) {
			this->pret = v_pret;
		}
	}
	void setNrCamere(unsigned int v_numar_camere)
	{
		if (v_numar_camere > 0) {
			this->numar_camera = v_numar_camere;
		}
	}
	void setSuprafCam(float* v_suprafete_camere) {
		if (this->suprafate_camere != NULL) {
			delete[]this->suprafate_camere;
		}
		if (v_suprafete_camere != NULL) {
			this->suprafate_camere = new float[this->numar_camera];
			for (int i = 0; i < this->numar_camera; i++) {
				this->suprafate_camere[i] = v_suprafete_camere[i];
			}
		}
	}
	unsigned int getId() {
		return this->id;
	}
	string getAdresa() {
		return this->adresa;
	}
	char* getProprietar() {
		return this->proprietar;

	}
	double getPret() {
		return this->pret;
	}
	unsigned int getNrCam() {
		return this->numar_camera;
	}
	float* getSuprafCam() {
		return this->suprafate_camere;
	}
};

int main()
{
	// Test commands
	Apartament apart; //default constructor no parameters
	apart.afisare();
	cout << "-----------------------------------------------------" << endl;
	cin >> apart;
	cout << "-----------------------------------------------------" << endl;
	cout << apart;
	cout << "-----------------------------------------------------" << endl;
	Apartament apart2(1,"My adress","Ion Paunescu",12.4,2,new float[2] { 12.5f, 15.2f});
	apart2.afisare();
	cout << "-----------------------------------------------------" << endl;
	// Test Setteri
	cout << "Setteri au fost folositi pentru obiectul 'apart2'" << endl;
	apart2.setAdresa("My new address");
	apart2.setProprietar("Popescu Ion");
	apart2.setNrCamere(1);
	apart2.setPret(15.5);
	apart2.setSuprafCam(new float[1] { 21.5f });
	cout << "-----------------------------------------------------" << endl;
	// Test Getteri
	cout << "Getteri" << endl;
	cout << "Id apartament : " << apart2.getId() << endl;
	cout << "Adresa : " << apart2.getAdresa()<<endl;
	cout << "Nume proprietar : "<<apart2.getProprietar()<<endl;
	cout << "Pret : "<<apart2.getPret()<<endl;
	cout << "Numar camere : "<<apart2.getNrCam()<<endl;
	cout << "Suprafete camere : "<<endl;
	float *sup = apart2.getNumePersoane();
	for (int i = 0; i < apart2.getSuprafCam(); i++)
	{
		cout << i + 1 << ". " << sup[i] << endl;
	}
	cout << "-----------------------------------------------------" << endl;
	// Test Operatori -> aici cam astea sunt testele in functie si de cerintele date de el
	cout << "Operator overloading" << endl;
	cout << "String cast operator : " << (string)apart2 << endl;
	cout << "() operator(nume care incep cu vocala) : " << apart2() << endl;
	++apart2;
	cout << "++(pre) operator : " << apart2.getPret() << endl;
	apart2++;
	cout << "(post)++ operator : " << apart2.getPret() << endl;
	--apart2;
	cout << "--(pre) operator : " << apart2.getPret() << endl;
	apart2--;
	cout << "(post)-- operator : " << apart2.getPret() << endl;
	apart2 += apart;
	cout << "+= operator : " << apart2.getPret() << endl;
	cout << "[] operator : " << apart2[0] << endl;
	cout << "! operator : " << !apart2 << endl;
	cout << "== operator : " << (apart2 == apart) << endl;
	cout << "> operator : " << (apart2 > apart) << endl;
	cout << ">= operator : " << (apart2 >= apart) << endl;
	cout << "< operator : " << (apart2 < apart) << endl;
	cout << "<= operator : " << (apart2 <= apart) << endl;
	apart2 = apart2 + apart;
	cout << "+ operator : " << apart2.getPret() << endl;
	apart2 = apart2 - apart;
	cout << "- operator : " << apart2.getPret() << endl;
	cout << "-----------------------------------------------------" << endl;
	_getch();
	return 0;
}