THMMY.gr

#include <iostream>
#include <cstdlib>
#define MACHINE_POWER 100

using namespace std;
/* Orismos abstract klasews.
   mpainoun statikes metavlites.
   sinithws exoume 4. 1 zeugos gia tin main
   kai ena gia ta dokimastika antikeimena */
   
class Device{
		char *single_id;
	protected:
		static Device **Devices;
		static int n;
		static Device **ID;
		static int m;
	public:
		Device();
		Device(char *id);
		char *getType(){return single_id;}
		static Device ** getDevices(){return Devices;}
		static long int getN(){return n;}
		static short int getM(){return m;}
		static Device ** getID(){return ID;}
		virtual void create(int num) = 0;
		virtual float getImax(float V) = 0;
		virtual int getFuseType(float I) = 0;
		virtual float getPmax() = 0;
		virtual float getCable() = 0;
};

Device **Device::Devices;
Device **Device::ID;
int Device::n;
int Device::m;

Device::Device(){
	n++;
	if(n==1){
		Devices = (Device **)malloc(sizeof(Device *));
	}
	else{
		Devices = (Device **)realloc(Devices, n * sizeof(Device *));
	}
	Devices[n-1] = this;
}

Device::Device(char *id){
	single_id = id;
	m++;
	if(m==1){
		ID = (Device **)malloc(sizeof(Device *));
	}else{
		ID = (Device **)realloc(ID, m*sizeof(Device *));
	}
	ID[m-1] = this;
}

class Device1:public Device{
	float Pmax, dist;
	public:
		Device1();
		Device1(char *p):Device(p){}
		void create(int num);
		float getImax(float V);
		float getPmax();
		int getFuseType(float I);
		float getCable(){return dist;}
}TEMPORARY_ITEM_1("Device 1");

Device1::Device1():Device(){
	cout << "Give Pmax, dist\n";
	cin >> Pmax >> dist;
}
		
void Device1::create(int num){
	Device1 *p;
	p = new Device1[num];
	if(p == 0){
		cout << "Could not allocate memory. Terminating program...\n";
		exit(0);
	}
}

float Device1::getImax(float V){
	return Pmax/V;
}

float Device1::getPmax(){
	return Pmax;
}

int Device1::getFuseType(float I){
	if(I <= 10){
		return 0;
	}
	else if(I <= 16){
		return 1;
	}
	else if(I <= 20){
		return 2;
	}
	else if(I <= 25){
		return 3;
	}
	else{
		return -1;
	}
}

class Device2:public Device{
	float Pmax, dist, c;
	public:
		Device2();
		Device2(char *p):Device(p){}
		void create(int num);
		float getImax(float V);
		float getPmax();
		int getFuseType(float I);
		float getCable(){return dist;}
}TEMPORARY_ITEM_2("Device 2");

Device2::Device2():Device(){
	cout << "Give Pmax, dist, c\n";
	cin >> Pmax >> dist >> c;
}
	
void Device2::create(int num){
	Device2 *p;
	p = new Device2[num];
	if(p == 0){
		cout << "Could not allocate memory. Terminating program..\n";
		exit(0);
	}
}

float Device2::getImax(float V){
	return (Pmax + MACHINE_POWER*c)/V;
}

float Device2::getPmax(){
	return Pmax;
}

int Device2::getFuseType(float I){
	if(I <= 10){
		return 0;
	}
	else if(I <= 16){
		return 1;
	}
	else if(I <= 20){
		return 2;
	}
	else if(I <= 25){
		return 3;
	}
	else{
		return -1;
	}
}


float get_total_P(Device **devices, float voltage, int numberOfDevices, int *fuseNumber, float *fuseCable){
	float totalPower = 0;
	for(int i=0; i < numberOfDevices; i++){
		int fuse = devices[i]->getFuseType(devices[i]->getImax(voltage));
		switch(fuse){
			case -1:
				cout << "A device has current more that 25 A. It will be excluded.\n";
				break;
			default:
				totalPower += devices[i]->getPmax();
				fuseNumber[fuse]++;
				fuseCable[fuse] += devices[i]->getCable();
		}
	}
	return totalPower;
}
				
main(){
	Device **types;
	types = Device::getID();
	int fuseNumber[] = {0, 0, 0, 0};
	float voltage, fuseCable[] = {0, 0, 0, 0};
	cout << "Give Voltage.\n";
	cin >> voltage;
	int numberOfTypes = Device::getM();
	for(int i=0; i<numberOfTypes; i++){
		cout << "Give number of Devices of category: " << types[i]->getType() << "\n";
		int numberOfDevices;
		cin >> numberOfDevices;
		if(numberOfDevices == 0){
			continue;
		}else{
			types[i]->create(numberOfDevices);
		}
	}
	float Power = get_total_P(Device::getDevices(), voltage, Device::getN(), fuseNumber, fuseCable);
	cout << "Total power required for eligible devices: " << Power << "\n";
	for(int i=0; i<4; i++){
        cout << fuseNumber[i] << " " << fuseCable[i] << "\n";
    }
}