v8 pers_calc

#include <iostream>
#include <fstream>
#include <map>
using namespace std;

class Calc {
private:
    float pret;
public:
    int idCalc;
    char marca[30];

    //  ctor default
    Calc() {
        idCalc = 1000;
        strcpy(marca, "Noname");
        pret = 2000;
    }

    //  ctor cu param
    Calc(int idCale, char* marca, float pret) {
        this->idCalc = idCale;
        strcpy(this->marca, marca);
        this->pret = pret;
    }

    //  ctor de copiere
    Calc(const Calc& c) {
        this->idCalc = c.idCalc;
        strcpy(this->marca, c.marca);
        this->pret = c.pret;
    }

    // dtor
    ~Calc() {

    }

    //  pretul este privat in cerinta, deci avem nevoie de getter
    float getPret() {
        return pret;
    }

    //  supraincarcare op egal
    Calc& operator=(const Calc& c) {
        this->idCalc = c.idCalc;
        strcpy(this->marca, c.marca);
        this->pret = c.pret;
    }

    //  headere functii friend de suprainc op de flux
    friend ostream& operator << (ostream& os, Calc& c);
    friend ofstream& operator << (ofstream& os, Calc& c);
    friend ifstream& operator >> (ifstream& is, Calc& c);

    //  random shit; o supraincarcare a lui + ca sa faca inmultire;
    friend float operator+(Calc& a, Calc& b) {
        float rezultat = a.getPret() * b.getPret(); //  aici e toata treaba; ia elementele astea si le inmulteste in loc sa faca adunare;
            // lejer
        return rezultat;
    }
};

//  supraincarcare <<
ostream& operator<<(ostream& os, Calc& c) {
    os << "ID Calculator: " << c.idCalc << endl
        << "Marca: " << c.marca << endl
        << "Pret: " << c.pret << endl;

    return os;
}
//  supraincarcare op << fisiere
ofstream& operator << (ofstream& os, Calc& c) {
    os << c.idCalc << endl
        << c.marca << endl
        << c.pret << endl;

    return os;
}

//  supraincarcare op >> fisiere
ifstream& operator >> (ifstream& is, Calc& c) {
    is >> c.idCalc >> c.marca >> c.pret;
    return is;
}

class Pers {
public:
    int idPers;
    char nume[30];
    Calc* pCalc;
    int idCalc;

    // ctor default
    Pers() {
        idPers = 100;
        strcpy(nume, "Anonim");
        pCalc = NULL;
        idCalc = 0;
    }

    // ctor cu param
    Pers(int idPers, char* nume) {
        this->idPers = idPers;
        strcpy(this->nume, nume);
        pCalc = NULL;
        idCalc = 0;
    }

    //  dtor
    ~Pers() {

    }

    //  supraincarcare << pt asocierea unui calculator unei persoane ( ex. p1 << c1)
    void operator << (Calc& c) {
        this->pCalc = (Calc*)&c;
        this->idCalc = c.idCalc;
    }

    //  headere functii friend de supraincarcare op de flux
    friend ostream& operator << (ostream& os, Pers& p);
    friend ofstream& operator << (ofstream& os, Pers& p);
    friend ifstream& operator >> (ifstream& is, Pers& p);

    //  supraincarcare > pt if(p1 > c2)
    bool operator > (Calc& c) {
        if (this->pCalc->getPret() > c.getPret())
            return true;
        else
            return false;
    }

    //  supraincarcare > pt acea comparatie if(p1 > p2)
    bool operator > (Pers& p) {
        if (this->pCalc->getPret() > p.pCalc->getPret())
            return true;
        else
            return false;
    }
};

//  supraincarcare flux <<
ostream& operator << (ostream& os, Pers& p) {
    os << "ID Persoana: " << p.idPers << endl
        << "Nume: " << p.nume << endl
        << "Calculator" << endl
        << *p.pCalc << endl;

    return os;
}

// supraincarcare flux << pt fisiere
ofstream& operator << (ofstream& os, Pers& p) {
    os << p.idPers << endl
        << p.nume << endl
        << p.idCalc << endl;
    return os;
}

//  supraincarcare flux >> pt fisiere
ifstream& operator >> (ifstream& is, Pers& p) {
    is >> p.idPers >> p.nume >> p.idCalc;
    return is;
}

void main() {
    // instantiere obiecte
    Pers p1(123, "Popescu"), p2, p3, p4;
    Calc c1(1001, "Fujitsu", 3200), c2(1002, "Acer", 3500), c3, c4;

    //  calculatoru` 1 este asociat persoanei 1; analog pt 2
    p1 << c1; p2 << c2;

    //  afisare informatii calculator 1
    cout << c1;

    //  afisare informatii persoana 1 si 2
    cout << p1 << p2;

    //  instantiere calculator pt. persoana 4 (sa zicem ca si-a cumparat un calculator nou)
    p4.pCalc = new Calc(1004, "Dell", 2500);

    //  verificare preturi calculatoare persoana - calculator (e putin ambigua treaba asta; cum era in cerinta, asa am facut)
    if (p1 > c2) cout << p1.nume << " are un calculator mai scump decat " << c2.marca << endl;
    else cout << p1.nume << " are un calculator mai iefitn decat " << c2.marca << endl;

    //  verificare preturi calculatoare pt persoane (asta e mai normal :))) )
    if (p1 > p2) cout << p1.nume << " are un calculator mai scump decat " << p2.nume << endl;
    else cout << p1.nume << " are un calculator mai ieftin decat " << p2.nume << endl;

    // instantiere fisiere iesire
    ofstream calcOut("calc.txt", ios::app | ios::out);
    ofstream persOut("pers.txt", ios::app | ios::out);

    //  se salveaza datele calculatoarelor in fisierul de iesire insantiat anterior
    calcOut << c1; calcOut << c2;

    //  salvare date persoane in fisierul instantiat anterior
    persOut << p1; persOut << p2;


    //  instantiere fisiere intrare
    ifstream calcInp("calc.txt", ios::in);
    ifstream persInp("pers.txt", ios::in);

    //  se preiau din fisier datele pt c3, c4
    calcInp >> c3; calcInp >> c4;

    //  afisare date c3, c4
    cout << c3 << c4;

    //  instantiere map
    map<int, Calc> reteaCalc;

    //  inserare date in map
    reteaCalc.insert(pair<int, Calc>(c3.idCalc, c3));
    reteaCalc.insert(make_pair(c4.idCalc, c4));

    //  citire persoane din fisier
    persInp >> p3;
    persInp >> p4;

    //  instantiere iterator
    map<int, Calc>::iterator it;

    //  iterator ia valoarea pe care o gaseste dupa id-ul cautat
    it = reteaCalc.find(p3.idCalc);

    //  calculatorul persoanei 3 este a 2-a valoare stocata in iterator
    p3.pCalc = &(it->second);

    //  afisare data persoana 3
    cout << p3;

    //  test supraincarcare + ca sa faca inmultire;
    float rezultat = c1 + c2;
    cout << rezultat << endl;
}