// main.cpp
#include <iostream>
#include "SzlifierkaKatowa.h"
#include "WiertarkoWkretarka.h"
#include "head.h"

using namespace std;

int main()
{
    SzlifierkaKatowa* tab_szlifierki[ILE];
    WiertarkoWkretarka* tab_wiertarki[ILE];

    tab_szlifierki[0] = new SzlifierkaKatowa("BOSH", 10000, 1000, 9);
    tab_wiertarki[0] = new WiertarkoWkretarka("Siemens", 1000, 800, "bateria", 10);

    wypisz_najkrotszy_czas(tab_wiertarki);
    wypisz_najwieksze_obroty(tab_szlifierki);

    for(int i = 0; i < ILE; ++i)
    {
        if(tab_szlifierki[i])
            delete tab_szlifierki[i];
        if(tab_wiertarki[i])
            delete tab_wiertarki[i];
    }
    return 0;
}

// Urzadzenie.h
#ifndef URZADZENIE_H
#define URZADZENIE_H

#include <iostream>

using namespace std;

class Urzadzenie
{
    public:
        Urzadzenie(string, int);
        string daj_firme();
        int daj_obroty();
        virtual void pokaz_opis() = 0;      // metoda czysto wirtualna
    protected:
        string firma;
        int obroty;
};

#endif // URZADZENIE_H

// Urzadzenie.cpp
#include "Urzadzenie.h"

/*class Urzadzenie
{
    public:
        Urzadzenie(string, int);
        string daj_firme();
        int daj_obroty();
        virtual void pokaz_opis() = 0;      // metoda czysto wirtualna
    protected:
        string firma;
        int obroty;
};*/

Urzadzenie::Urzadzenie(string firm, int obr) : firma(firm), obroty(obr)
{
}

int Urzadzenie::daj_obroty()
{
    return obroty;
}

// SzlifierkaKatowa.h
#ifndef SZLIFIERKAKATOWA_H
#define SZLIFIERKAKATOWA_H

#include "Urzadzenie.h"

class SzlifierkaKatowa : public Urzadzenie
{
    /*class Urzadzenie
{
    public:
        Urzadzenie(string, int);
        string daj_firme();
        int daj_obroty();
        virtual void pokaz_opis() = 0;      // metoda czysto wirtualna
    protected:
        string firma;
        int obroty;
};*/
    public:
        SzlifierkaKatowa(string, int, int, int);
        int daj_moc();
        int daj_tarcze();
        void pokaz_opis();
    private:
        int moc;
        int tarcza;
};

#endif // SZLIFIERKAKATOWA_H

// SzlifierkaKatowa.cpp
#include "SzlifierkaKatowa.h"
#include "Urzadzenie.h"
#include <iostream>

using namespace std;

/*class SzlifierkaKatowa : public Urzadzenie
{
    /*class Urzadzenie
{
    public:
        Urzadzenie(string, int);
        string daj_firme();
        int daj_obroty();
        virtual void pokaz_opis() = 0;      // metoda czysto wirtualna
    protected:
        string firma;
        int obroty;
};
    public:
        SzlifierkaKatowa(string, int, int, int);
        int daj_moc();
        int daj_tarcze();
        void pokaz_opis();
    private:
        int moc;
        int tarcza;
};*/

SzlifierkaKatowa::SzlifierkaKatowa(string firm, int obr, int power, int shield) : Urzadzenie(firm, obr), moc(power), tarcza(shield)
{
}

void SzlifierkaKatowa::pokaz_opis()
{
    cout << "Firma: " << firma << endl;
    cout << "Obroty: " << obroty << endl;
    cout << "Moc: " << moc << endl;
    cout << "Tarcza: " << tarcza << endl;
}

int SzlifierkaKatowa::daj_moc()
{
    return moc;
}

int SzlifierkaKatowa::daj_tarcze()
{
    return tarcza;
}

// WiertarkoWkretarka.h
#ifndef WIERTARKOWKRETARKA_H
#define WIERTARKOWKRETARKA_H

#include "Urzadzenie.h"

using namespace std;

class WiertarkoWkretarka : public Urzadzenie
{
    /*class Urzadzenie
{
    public:
        Urzadzenie(string, int);
        string daj_firme();
        int daj_obroty();
        virtual void pokaz_opis() = 0;      // metoda czysto wirtualna
    protected:
        string firma;
        int obroty;
};*/
    public:
        WiertarkoWkretarka(string, int, double, string, int);
        double daj_napiecie();
        string daj_baterie();
        int daj_czas_ladow();
        void pokaz_opis();
    private:
        double napiecie;
        string bateria;
        int czas_ladow;
};

#endif // WIERTARKOWKRETARKA_H

// WiertarkoWkretarka.cpp
#include "WiertarkoWkretarka.h"
#include <iostream>

using namespace std;

/*class WiertarkoWkretarka : public Urzadzenie
{
    class Urzadzenie
{
    public:
        Urzadzenie(string, int);
        string daj_firme();
        int daj_obroty();
        virtual void pokaz_opis() = 0;      // metoda czysto wirtualna
    protected:
        string firma;
        int obroty;
};
    public:
        WiertarkoWkretarka(string, int, double, string, int);
        double daj_napiecie();
        string daj_baterie();
        int daj_czas_ladow();
        void pokaz_opis();
    private:
        double napiecie;
        string bateria;
        int czas_ladow;
};*/

WiertarkoWkretarka::WiertarkoWkretarka(string firm, int obr, double nap, string battery, int time) : Urzadzenie(firm, obr), napiecie(nap), bateria(battery), czas_ladow(time)
{
}

void WiertarkoWkretarka::pokaz_opis()
{
    cout << "Firma: " << firma << endl;
    cout << "Obroty: " << obroty << endl;
    cout << "Napiecie: " << napiecie << endl;
    cout << "Bateria: " << bateria << endl;
    cout << "Czas ladowania: " << czas_ladow << endl;
}

double WiertarkoWkretarka::daj_napiecie()
{
    return napiecie;
}

string WiertarkoWkretarka::daj_baterie()
{
    return bateria;
}

int WiertarkoWkretarka::daj_czas_ladow()
{
    return czas_ladow;
}

// head.h
#ifndef HEAD
#define HEAD

#include "SzlifierkaKatowa.h"
#include "WiertarkoWkretarka.h"

const int ILE = 5;

void wypisz_najkrotszy_czas(WiertarkoWkretarka**);
void wypisz_najwieksze_obroty(SzlifierkaKatowa**);

#endif // HEAD

// funkcje.cpp
#include "head.h"

void wypisz_najkrotszy_czas(WiertarkoWkretarka** tablica)
{
    int czas = tablica[0]->daj_czas_ladow();
    int element = 0;

    for(int i = 1; i < ILE; ++i)
        if(tablica[i]->daj_czas_ladow() < czas)
        {
            element = i;
            czas = tablica[i]->daj_czas_ladow();
        }
    tablica[element]->pokaz_opis();
}

void wypisz_najwieksze_obroty(SzlifierkaKatowa** tablica)
{
    int obroty = tablica[0]->daj_obroty();
    int element = 0;

    for(int i = 1; i < ILE; ++i)
        if(tablica[i]->daj_obroty() > obroty)
        {
            element = i;
            obroty = tablica[i]->daj_obroty();
        }
    tablica[element]->pokaz_opis();
}