KotProgV2.1

#include <iostream>
#include <fstream>
#include <typeinfo>


/*
Hozz létre egy Telefon osztályt, ami egy telefont reprezentál.
A telefonnak legyen száma (9 jegyû szám, vagy 9 karakteres tömb), valamint felhasználható internet mennyiségét (double, megabájtban számolva).
Az osztálynak legyen:
Egy olyan konstruktora, ami a paraméterként várja a számot, és a felhasználható internet mennyiségét
Egy olyan konstruktora, ami a konzolról olvassa be az adatokat.
Egy internetHasznál() függvénye, amely a paraméterben megadott számmal csökkenti a felhasználható internet mennyiségét.
Amennyiben paraméter nélkül hívjuk meg a függvényt, pontosan 1.2 megabájttal csökkenjen a felhasználható keret.
Egy feltölt() függvény, amely pontosan 500 megabájtot ad hozzá a felhasználható internethez,
 de ügyelj rá, hogy a felhasználható keret legfeljebb 1500 megabájt legyen. Ezen érték felé ne emelkedhessen a szám!
Egy adatok() függvény, ami kiírja az alapértelmezett kimenetre a számot és a felhasználható internet mennyiségét.
Származtass le az Telefon osztályból egy SzuperNetezõTelefon osztályt, ami tárolja magáról, hogy használhat-e 4G-t vagy sem (bool).

Az osztálynak legyen:
Egy olyan konstruktora, ami a paraméterként várja a számot, a felhasználható internet mennyiségét, és azt, hogy használhat-e 4G-t.
Egy save függvénye, ami a paraméterül kapott fájlba elmenti az adatokat.
Felüldefiniált internetHasznál() függvénye, amely a paraméterben megadott számmal csökkenti a felhasználható internet mennyiségét.
Amennyiben paraméter nélkül hívjuk meg a függvényt, pontosan 23.5 megabájttal csökkenjen a felhasználható keret.
Felüldefiniált feltölt() függvénye, amely pontosan 500 megabájtot ad hozzá a felhasználható internethez, korlátozás nélkül.
Készíts egy main függvényt, ami az elkészült osztályokat (függvényeivel együtt) teszteli!
*/


using namespace std;

class Telefon{

    protected:
        int number[9];
    public:
        double data;
        Telefon(int[],double);
        Telefon();
        virtual ~Telefon(){}
        void internetHasznal();
        void internetHasznal(double);
        void feltolt();
        void adatok();

};

Telefon :: Telefon(int number[9], double data){

    // cout << "A megadott telefonszám: ";

        for(int i = 0; i<9; i++){
            this->number[i] = number[i];
            // cout << number[i];
        }

    //cout << endl;

    this->data = data;

    //cout << "A megadott felhasználható adatmennyiség: " << data << " MB" << endl;

}

Telefon :: Telefon(){

    cout << "Adja meg a 9 jegyu telefonszamot, szokozzel elvalasztva!" << endl;
        for(int i = 0; i<9; i++){
            cin >> number[i];
        }

    cout << "Adja meg a felhasznalhato internet mennyiseget megabajtban!" << endl;
    cin >> data;

}

void Telefon :: internetHasznal(double hasznal){

    if((data-hasznal) <= 0){
        data = 0;
    } else data-=hasznal;

    if(data == 0){
        cout << "Nincs felhasznalhato adatkeret!" << endl;
    }else cout << "Felhasznalast koveto adatkeret: " << data << endl;
}

void Telefon :: internetHasznal(){

    if((data-1.2) <= 0){
        data = 0;
    } else data-=1.2;

    if(data == 0){
        cout << "Nincs felhasznalhato adatkeret!" << endl;
    }else cout << "Felhasznalast koveto adatkeret: " << data << endl;

}

void Telefon :: feltolt(){


    if((data+500)>=1500){
        data = 1500;
    }else data+=500;

    cout << "Feltoltes utani aktualis adatkereted: " << data << " MB" << endl;

}

void Telefon :: adatok(){

    cout << "Telefonszam: ";

        for(int i = 0; i<9; i++){
            cout << number[i];
        }

    cout << endl;

    cout << "Adatkeret: " << data << " MB" << endl;

}

class SzuperNetezoTelefon : public Telefon{
        bool negyG;

    public:

        SzuperNetezoTelefon(int[],double,bool);
        void save(char*);
        void internetHasznal();
        void internetHasznal(double);
        void feltolt();
};

SzuperNetezoTelefon :: SzuperNetezoTelefon(int number[9], double data, bool negyG): Telefon(number,data) {
    this->negyG = negyG;
}


void SzuperNetezoTelefon ::save (char* fname){
    ofstream o(fname);

    for(int i = 0; i<9; i++){
        o << number[i];
    }

    o << endl << data << endl;
    o.close();
}

void SzuperNetezoTelefon :: internetHasznal(double hasznal){

    if((data-hasznal) <= 0){
        data = 0;
    } else data-=hasznal;

    if(data == 0){
        cout << "Nincs felhasznalhato adatkeret!" << endl;
    }else cout << "Felhasznalast koveto adatkeret: " << data << endl;
}

void SzuperNetezoTelefon :: internetHasznal(){

    if((data-23.5) <= 0){
        data = 0;
    } else data-=23.5;

    if(data == 0){
        cout << "Nincs felhasznalhato adatkeret!" << endl;
    }else cout << "Felhasznalast koveto adatkeret: " << data << endl;

}

void SzuperNetezoTelefon :: feltolt(){

    data+=500;

    cout << "Feltoltes utani aktualis adatkereted: " << data << " MB" << endl;

}

/*
Hozz létre egy TelefonKatalógus nevű osztályt, ami Telefon objektumokat tud tárolni.
Legyen egy konstruktora, amely paraméterül vár egy számot. Ennyi Telefon objektumra mutató pointernek foglajon dinamikusan helyet.
Készíts egy add metódust (ami logikai értékkel tér vissza), amely a telefon katalógushoz hozzáadja a paraméterből érkező telefon objektumot
(A telefon objektumról másolatot készítsünk, copy konstruktorral), egészen addig, amíg van hely. Ha nincs már hely, ne csináljon semmit,
csak térjen vissza false értékkel.
Definiáld felül a prefix ++ operátort, amely az összes telefon felhasználható internet mennyiségét megnöveli 100 megabájttal.
Definiáld felül a tömbindex operátort, amely térjen vissza a tárolt telefonok közül a paraméterben megadott indexűvel,
amennyiben az létezik. Amennyiben nem, térjen vissza az utolsó tárolt indexen lévő telefonnal
Definiáld felül az ostream << operátorát, aminek segítségével írasd ki az összes tárolt telefon darabszámát,
és a telefonokra egyesével hívja meg az adatok() függvényt.
Készíts destruktort, amely felszabadítja a tárolt objektumokat, és a tárulásokra használt pointer tömböt.
Készíts egy main függvényt, amely:
Létrehoz egy TelefonKatalógus objektumot, amiben helyet foglaltat 100 telefonnak
Adj hozzá 2 Telefon és 3 SzuperNetezőTelefon objektumot.
Írasd ki << operátorral ( cout << … ).
Hívd meg a ++ operátort.
Szabadítsd föl minden lefoglalt memóriaterületet.
*/

class TelefonKatalogus {

    int n;

public:
    Telefon **m;
    string* type;
    int cnt;
    TelefonKatalogus(int);
    ~TelefonKatalogus();
    TelefonKatalogus(TelefonKatalogus*);
    bool add(Telefon&);
    void operator++();
    Telefon& operator[](int index);
    friend ostream& operator<<(ostream&,TelefonKatalogus&);
};

TelefonKatalogus::TelefonKatalogus(TelefonKatalogus* tk) {
    n = tk->n;
    *m = new Telefon[n];
    for(int i = 0; i<cnt; i++){
        m[i] = tk->m[i];
    }
}


TelefonKatalogus::TelefonKatalogus(int n) {
    this->cnt = 0;
    this->n = n;
    this->m = new Telefon*[n];

    for(int i = 0; i<n; i++){
        m[i] = NULL; // NULL ra állítom az értékeket.
    }
    type = new string[n];

    for(int i = 0; i<n; i++){
        type[i].clear();
    }
}




TelefonKatalogus::~TelefonKatalogus() {

    for(int i = 0; i<cnt; i++){
        delete &m[i];
    }
    delete []m;
    delete type;
}


bool TelefonKatalogus::add(Telefon& t){

    if(cnt<this->n){
        type[cnt] = typeid(t).name();
        Telefon *tcopy = new Telefon(t);
        this->m[cnt] = tcopy;
        cnt++;
        return true;

    }else{
        return false;
    }

}


void TelefonKatalogus::operator++() {
    for (int i=0;i<cnt;i++){
            if(type[i] == typeid(Telefon).name()){
                if((m[i]->data+100)<=1500){
                    m[i]->data+=100;
                }
            }else m[i]->data+=100;

    }
}



Telefon& TelefonKatalogus::operator[](int index){
    if(index<=cnt-1){
        return *m[index];
    }else return *m[cnt-1];
}

ostream& operator<<(ostream &o,TelefonKatalogus &tk) {
    o << tk.cnt << "db telefon van a katalogusban!" << endl;

    for(int i = 0; i<tk.cnt; i++){
        tk.m[i]->adatok();
    }
}



int main()
{
    setlocale(LC_ALL,"hun");

    int telefonszam1[9] = {0,6,1,1,1,1,1,1,1};
    int telefonszam2[9] = {0,6,2,2,2,2,2,2,2};
    int telefonszam3[9] = {0,6,3,3,3,3,3,3,3};
    int telefonszam4[9] = {0,6,4,4,4,4,4,4,4};
    int telefonszam5[9] = {0,6,5,5,5,5,5,5,5};

    Telefon t1(telefonszam1,1500.0);
    Telefon t2(telefonszam2,1500.0);
    SzuperNetezoTelefon sznt1(telefonszam3,1500.0, true);
    SzuperNetezoTelefon sznt2(telefonszam4,1500.0, true);
    SzuperNetezoTelefon sznt3(telefonszam5,1500.0, true);


    // 100 ferohelyes katalogus letrehozasa
    TelefonKatalogus tk(100);

    // telefonok hozzaadasa a katalogushoz
    tk.add(t1);
    tk.add(t2);
    tk.add(sznt1);
    tk.add(sznt2);
    tk.add(sznt3);

    // default copy constructor segitsegevel lemasolom az eredeti tk-t
    TelefonKatalogus tk2(tk);

    // << operator overloading
    cout << tk2;

    cout << endl;

    // prefix ++ operator overloading
    ++tk2;

    // [TESZT] tomb index operator overloading
    tk2[0].adatok();
    tk2[1].adatok();
    tk2[2].adatok();
    tk2[3].adatok();
    tk2[4].adatok();
    tk2[5].adatok(); // itt is a 4. indexen levot fogja meghivni





/*
    int telefonszam[9] = {1,2,3,4,5,6,7,8,9};

    Telefon *t = new Telefon(telefonszam,1500.0);
    // Telefon *t = new Telefon();
    t->internetHasznal(500.0);
    // t->internetHasznal();
    t->feltolt();
    t->adatok();
    delete t;


    SzuperNetezoTelefon *t = new SzuperNetezoTelefon(telefonszam,3000.0,true);
    t->save("num_dat.txt");
    t->internetHasznal(1000.0);
    // t->internetHasznal();
    t->feltolt();
    delete t;
*/

    return 0;
}