[OOP] LV3 - Zadaci + Analiza

// Zadaci
// 1. zadatak
// ---------------------------------------

class Prepaid {
protected:
    float mBalance;
public:
    Prepaid();
    Prepaid(float);
    void AddMoney(float);
    float GetBalance() const;
    virtual void SendSMS() = 0;
};

// ---------------------------------------

Prepaid::Prepaid() : mBalance(0) {}

Prepaid::Prepaid(float balance) : mBalance(balance) {}

void Prepaid::AddMoney(float nadoplata) {
    mBalance += nadoplata;
}

float Prepaid::GetBalance() const {
    return mBalance;
}

// ---------------------------------------

class Tele2 : public Prepaid {
private:
    float mPrice;
public:
    Tele2();
    Tele2(float, float);
    void SendSMS();
};

// ---------------------------------------

Tele2::Tele2() : mPrice(0), Prepaid() {}

Tele2::Tele2(float price, float balance) : mPrice(price), Prepaid(balance) {}

void Tele2::SendSMS() {
    mBalance -= mPrice;
    cout << "Message sent! Message price: " << mPrice << "$" <<endl;
}

// ---------------------------------------

int main() {
    Tele2 Korisnik(2.3, 50);
    Prepaid *p;

    p = &Korisnik;
    cout << "Balance: " << p->GetBalance() << "$" << endl;
    p->SendSMS();
    cout << "Balance: " << p->GetBalance() << "$" << endl;

    return 0;
}

// 2. zadatak
// ---------------------------------------

class Device {
protected:
    bool mPoweredON;
    string mDeviceID;
    string mManufacturer;
public:
    Device();
    Device(bool, string, string);
    virtual void TurnON_OFF();
};

// ---------------------------------------

Device::Device() : mPoweredON(false), mDeviceID(""), mManufacturer("") {}

Device::Device(bool PoweredON, string DeviceID, string Manufacturer) : mPoweredON(PoweredON), mDeviceID(DeviceID), mManufacturer(Manufacturer) {}

void Device::TurnON_OFF() { mPoweredON = !mPoweredON; }

// ---------------------------------------

class USBDevice : public virtual Device {
protected:
    bool mConnected;
    float mUSBStandard;
public:
    USBDevice();
    USBDevice(bool, float, bool, string, string);
    virtual void Connect();
};

// ---------------------------------------

USBDevice::USBDevice() : mConnected(false), mUSBStandard(2.0), Device(false, "", "") {}

USBDevice::USBDevice(bool Connected, float USBStandard, bool PoweredON, string DeviceID, string Manufacturer) : mConnected(Connected), mUSBStandard(USBStandard), Device(PoweredON, DeviceID, Manufacturer) {}

void USBDevice::Connect() { mConnected = !mConnected; }

// ---------------------------------------

class NetworkDevice : public virtual Device {
protected:
    bool mConnected;
    string mNetworkStandard;
public:
    NetworkDevice();
    NetworkDevice(bool, string, bool, string, string);
    virtual void Connect();
};

// ---------------------------------------

NetworkDevice::NetworkDevice() : mConnected(false), mNetworkStandard(""), Device(false, "", "") {}

NetworkDevice::NetworkDevice(bool Connected, string NetworkStandard, bool PoweredON, string DeviceID, string Manufacturer) : mConnected(Connected), mNetworkStandard(NetworkStandard), Device(PoweredON, DeviceID, Manufacturer) {}

void NetworkDevice::Connect() { mConnected = !mConnected; }

// ---------------------------------------

class WirelessAdapter : public USBDevice, public NetworkDevice {
private:
    int mAntennas;
    int mGain;
public:
    WirelessAdapter();
    WirelessAdapter(int, int, bool, float, string, bool, string, string);
    virtual void Connect();
    void Status();
};

// ---------------------------------------

WirelessAdapter::WirelessAdapter() : mAntennas(0), mGain(0), USBDevice(false, 2.0, false, "", ""), NetworkDevice(false, "", false, "", "") {}

WirelessAdapter::WirelessAdapter(int Antennas, int Gain, bool Connected, float USBStandard, string NetworkStandard, bool PoweredON, string DeviceID, string Manufacturer) : mAntennas(Antennas), mGain(Gain), USBDevice(Connected, USBStandard, PoweredON, DeviceID, Manufacturer), NetworkDevice(Connected, NetworkStandard, PoweredON, DeviceID, Manufacturer) {}

void WirelessAdapter::Connect() {
    USBDevice::Connect();
    NetworkDevice::Connect();
}

void WirelessAdapter::Status() {
    if (USBDevice::mPoweredON) {
        if (USBDevice::mConnected) {
            cout << "USB Device is connected!" << endl;
        }
        else {
            cout << "USB Device is disconnected!" << endl;
        }
    }
    else {
        cout << "USB Device is not powered on!" << endl;
    }

    if (NetworkDevice::mPoweredON) {
        if (NetworkDevice::mConnected) {
            cout << "Network Device is connected!" << endl;
        }
        else {
            cout << "Network Device is disconnected!" << endl;
        }
    }
    else {
        cout << "Network Device is not powered on!" << endl;
    }
}

// ---------------------------------------

int main() {
    WirelessAdapter Samsung;

    Samsung.TurnON_OFF();
    Samsung.Connect();
    Samsung.Status();

    return 0;
}

// Analiza
// 1. Napiši klasu MotornoVozilo koja ima podatkovne članove za boju, zapremninu
// spremnika goriva, trenutnu razinu goriva i prosječnu potrošnju, defaultni i
// parametarski konstruktor, metodu Oboji koja boja vozilo, Natoci koja puni
// gorivo i čistu virtualnu metodu Vozi, koja kao parametar ima broj kilometara
// koliko se vozi.Napiši klasu Automobil koja nasljeđuje klasu MotornoVozilo, a
// ima podatkovne članove za model i max.brzinu te defaultni i parametarski
// konstruktor.Prepiši metodu vozi, tako da umanjuje količinu goriva prema
// broju kilometara koje se vozi i prosječnoj potrošnji.Napraviti garažu(1D polje
// MotornihVozila) i provozati svako vozilo iz garaže.

// ---------------------------------------

class Vehicle {
protected:
    string mColor;
    float mFuelTank;
    float mFuelLevel;
    float mAverageConsumption;
public:
    Vehicle();
    Vehicle(string, float, float, float);
    void Paint(string);
    void Refuel(float);
    virtual void Drive(float) = 0;
};

// ---------------------------------------

Vehicle::Vehicle() : mColor(""), mFuelTank(0.0), mFuelLevel(0.0), mAverageConsumption(0.0) {}

Vehicle::Vehicle(string Color, float FuelTank, float FuelLevel, float AverageConsumption) : mColor(Color), mFuelTank(FuelTank), mFuelLevel(FuelLevel), mAverageConsumption(AverageConsumption) {}

void Vehicle::Paint(string color) {
    mColor = color;
}

void Vehicle::Refuel(float fuel) {
    mFuelTank += fuel;
}

// ---------------------------------------

class Car : public Vehicle {
private:
    string mModel;
    float mMaxSpeed;
public:
    Car();
    Car(string, float, string, float, float, float);
    virtual void Drive(float);
};

// ---------------------------------------

Car::Car() : mModel(""), mMaxSpeed(0.0), Vehicle("", 0.0, 0.0, 0.0) {}

Car::Car(string Model, float MaxSpeed, string Color, float FuelTank, float FuelLevel, float AverageConsumption) : mModel(Model), mMaxSpeed(MaxSpeed), Vehicle(Color, FuelTank, FuelLevel, AverageConsumption) {}

void Car::Drive(float distance) {
    if (mFuelLevel - mAverageConsumption * distance < 0) {
        mFuelLevel = 0;
    }
    else {
        mFuelLevel = mFuelLevel - mAverageConsumption * distance;
    }
}

// ---------------------------------------

int main() {
    float random;
    Vehicle** Garage = new Vehicle*[3] {
        new Car( "Opel", 200.00, "Black", 150.00, 70.00, 0.2 ),
        new Car( "Lamborghini", 300.00, "Yellow", 100.00, 10.00, 0.8 ),
        new Car( "Audi", 250.00, "White", 200.00, 120.00, 0.5 )
    };

    srand((unsigned int)time(0));
    for (int i = 0; i < 3; i++) {
        random = 100 + (float)rand() * 400 / (float)RAND_MAX;
        Garage[i]->Drive(random);
    }

    for (int i = 0; i < 3; i++) {
        delete Garage[i];
    }
    delete Garage;

    return 0;
}

// 2. Napiši klasu Kalkulator koja predstavlja i ima mogućnosti osnovnog kalkulatora
// (unesi operande, zbroji, oduzmi, pomnozi, podijeli, prikaži rezultat).Iz nje
// izvedi klasu znanstveni kalkulator koja omogućuje dodatne operacije poput
// korjenovanja, potenciranja te onih operacija koje smatrate nužnima.

// ---------------------------------------

class Calculator{
protected:
    double mResult;
public:
    Calculator();
    void Add(double, double);
    void Subtract(double, double);
    void Multiply(double, double);
    void Divide(double, double);
    void ShowResult() const;
};

// ---------------------------------------

Calculator::Calculator() : mResult(0.0) {}

void Calculator::Add(double A, double B) { mResult = A + B; }

void Calculator::Subtract(double A, double B) { mResult = A - B; }

void Calculator::Multiply(double A, double B) { mResult = A * B; }

void Calculator::Divide(double A, double B) { mResult = A / B; }

void Calculator::ShowResult() const { cout << mResult << endl; }

// ---------------------------------------

class ScientificCalculator : public Calculator {
public:
    void SquareRoot(double);
    void Power(double, double);
    void Sine(double);
    void Cosine(double);
};

// ---------------------------------------

void ScientificCalculator::SquareRoot(double X) { mResult = sqrt(X); }

void ScientificCalculator::Power(double Base, double Exponent) { mResult = pow(Base, Exponent); }

void ScientificCalculator::Sine(double X) { mResult = sin(X); }

void ScientificCalculator::Cosine(double X) { mResult = cos(X); }

// ---------------------------------------

int main() {
    ScientificCalculator Kalkulator;
    double a = 2.3, b = 4.6, x = 5.2;

    Kalkulator.Add(a, b);
    Kalkulator.ShowResult();

    Kalkulator.Subtract(a, b);
    Kalkulator.ShowResult();

    Kalkulator.Multiply(a, b);
    Kalkulator.ShowResult();

    Kalkulator.Divide(a, b);
    Kalkulator.ShowResult();

    Kalkulator.SquareRoot(x);
    Kalkulator.ShowResult();

    Kalkulator.Power(a, b);
    Kalkulator.ShowResult();

    Kalkulator.Sine(x);
    Kalkulator.ShowResult();

    Kalkulator.Cosine(x);
    Kalkulator.ShowResult();

    return 0;
}