gistfile1.txt

#include <iostream>
#include <string>
#include <cstring>
using namespace std;

// ============================================================
// Proiect Carte de Vizita ----> Clasa de baza
// ============================================================
class CarteDeVizita {
protected:
    // Campuri comune
    char* nume;           // alocat dinamic
    string telefon;
    string email;
    string companie;

    // Campuri specifice cartilor de vizita fizice
    string tipMaterial;   // ex: "carton", "plastic", "metal"
    int nrExemplare;
    double latime;        // dimensiuni in cm
    double inaltime;
    string categorie;     // ex: "business", "personal"
    double cost;

    // Membru static: contor total carti de vizita create
    static int totalCarti;

public:
    // --------------------------------------------------------
    // Constructori
    // --------------------------------------------------------

    // Constructor implicit
    CarteDeVizita()
        : telefon(""), email(""), companie(""),
          tipMaterial("carton"), nrExemplare(1),
          latime(9.0), inaltime(5.0),
          categorie("business"), cost(0.0)
    {
        nume = new char[1];
        nume[0] = '\0';
        totalCarti++;
    }

    // Constructor cu parametri
    CarteDeVizita(const char* _nume, const string& _telefon,
                  const string& _email, const string& _companie,
                  const string& _tipMaterial, int _nrExemplare,
                  double _latime, double _inaltime,
                  const string& _categorie, double _cost)
        : telefon(_telefon), email(_email), companie(_companie),
          tipMaterial(_tipMaterial), nrExemplare(_nrExemplare),
          latime(_latime), inaltime(_inaltime),
          categorie(_categorie), cost(_cost)
    {
        nume = new char[strlen(_nume) + 1];
        strcpy(nume, _nume);
        totalCarti++;
    }

    // Constructor de copiere
    CarteDeVizita(const CarteDeVizita& other)
        : telefon(other.telefon), email(other.email),
          companie(other.companie), tipMaterial(other.tipMaterial),
          nrExemplare(other.nrExemplare), latime(other.latime),
          inaltime(other.inaltime), categorie(other.categorie),
          cost(other.cost)
    {
        nume = new char[strlen(other.nume) + 1];
        strcpy(nume, other.nume);
        totalCarti++;
    }

    // Destructor
    virtual ~CarteDeVizita() {
        delete[] nume;
        totalCarti--;
    }

    // Operator de atribuire
    CarteDeVizita& operator=(const CarteDeVizita& other) {
        if (this != &other) {
            delete[] nume;
            nume = new char[strlen(other.nume) + 1];
            strcpy(nume, other.nume);
            telefon    = other.telefon;
            email      = other.email;
            companie   = other.companie;
            tipMaterial= other.tipMaterial;
            nrExemplare= other.nrExemplare;
            latime     = other.latime;
            inaltime   = other.inaltime;
            categorie  = other.categorie;
            cost       = other.cost;
        }
        return *this;
    }

    // --------------------------------------------------------
    // Getteri si Setteri
    // --------------------------------------------------------
    const char* getNume()       const { return nume; }
    string getTelefon()         const { return telefon; }
    string getEmail()           const { return email; }
    string getCompanie()        const { return companie; }
    string getTipMaterial()     const { return tipMaterial; }
    int    getNrExemplare()     const { return nrExemplare; }
    double getLatime()          const { return latime; }
    double getInaltime()        const { return inaltime; }
    string getCategorie()       const { return categorie; }
    double getCost()            const { return cost; }

    void setNume(const char* _nume) {
        delete[] nume;
        nume = new char[strlen(_nume) + 1];
        strcpy(nume, _nume);
    }
    void setTelefon(const string& t)    { telefon = t; }
    void setEmail(const string& e)      { email = e; }
    void setCompanie(const string& c)   { companie = c; }
    void setTipMaterial(const string& m){ tipMaterial = m; }
    void setNrExemplare(int n)          { nrExemplare = n; }
    void setDimensiuni(double l, double i){ latime = l; inaltime = i; }
    void setCategorie(const string& c)  { categorie = c; }
    void setCost(double c)              { cost = c; }

    // Membru static getter
    static int getTotalCarti() { return totalCarti; }

    // --------------------------------------------------------
    // (1p) Operator >= - comparatie dupa cost
    // --------------------------------------------------------
    bool operator>=(const CarteDeVizita& other) const {
        return this->cost >= other.cost;
    }

    // --------------------------------------------------------
    // (1p) Operator >> pentru citire de la tastatura
    // --------------------------------------------------------
    friend istream& operator>>(istream& in, CarteDeVizita& c) {
        string numeStr;
        cout << "  Nume: ";
        getline(in, numeStr);
        c.setNume(numeStr.c_str());

        cout << "  Telefon: ";
        getline(in, c.telefon);

        cout << "  Email: ";
        getline(in, c.email);

        cout << "  Companie: ";
        getline(in, c.companie);

        cout << "  Tip material (carton/plastic/metal): ";
        getline(in, c.tipMaterial);

        cout << "  Nr. exemplare: ";
        in >> c.nrExemplare;

        cout << "  Dimensiuni (latime inaltime in cm): ";
        in >> c.latime >> c.inaltime;

        cout << "  Categorie (business/personal): ";
        in.ignore();
        getline(in, c.categorie);

        cout << "  Cost (RON): ";
        in >> c.cost;
        in.ignore();

        return in;
    }

    // --------------------------------------------------------
    // Operator << pentru afisare (virtual pentru polimorfism)
    // --------------------------------------------------------
    virtual void afiseaza(ostream& out) const {
        out << "----------- Carte de Vizita -----------\n";
        out << "  Nume:         " << nume        << "\n";
        out << "  Telefon:      " << telefon     << "\n";
        out << "  Email:        " << email       << "\n";
        out << "  Companie:     " << companie    << "\n";
        out << "  Material:     " << tipMaterial << "\n";
        out << "  Nr exemplare: " << nrExemplare << "\n";
        out << "  Dimensiuni:   " << latime << " x " << inaltime << " cm\n";
        out << "  Categorie:    " << categorie   << "\n";
        out << "  Cost:         " << cost        << " RON\n";
    }

    friend ostream& operator<<(ostream& out, const CarteDeVizita& c) {
        c.afiseaza(out);
        return out;
    }
};

// Initializare membru static
int CarteDeVizita::totalCarti = 0;


// ============================================================
// (2p) Clasa derivata: CarteDeVizitaElectronica
// ============================================================
class CarteDeVizitaElectronica : public CarteDeVizita {
private:
    string urlProfil;      // ex: LinkedIn, website personal
    string qrCode;         // link QR Code
    string formatFisier;   // ex: "vCard", "PDF", "PNG"
    bool   estePublica;    // vizibila public sau nu

public:
    // Constructor implicit
    CarteDeVizitaElectronica()
        : CarteDeVizita(),
          urlProfil(""), qrCode(""),
          formatFisier("vCard"), estePublica(true)
    {}

    // Constructor cu parametri
    CarteDeVizitaElectronica(const char* _nume, const string& _telefon,
                              const string& _email, const string& _companie,
                              const string& _url, const string& _qr,
                              const string& _format, bool _publica)
        : CarteDeVizita(_nume, _telefon, _email, _companie,
                        "electronic", 1, 0.0, 0.0, "digital", 0.0),
          urlProfil(_url), qrCode(_qr),
          formatFisier(_format), estePublica(_publica)
    {}

    // Constructor de copiere
    CarteDeVizitaElectronica(const CarteDeVizitaElectronica& other)
        : CarteDeVizita(other),
          urlProfil(other.urlProfil), qrCode(other.qrCode),
          formatFisier(other.formatFisier), estePublica(other.estePublica)
    {}

    ~CarteDeVizitaElectronica() override {}

    // Getteri / Setteri specifice
    string getUrlProfil()    const { return urlProfil; }
    string getQrCode()       const { return qrCode; }
    string getFormatFisier() const { return formatFisier; }
    bool   getEstePublica()  const { return estePublica; }

    void setUrlProfil(const string& u)    { urlProfil = u; }
    void setQrCode(const string& q)       { qrCode = q; }
    void setFormatFisier(const string& f) { formatFisier = f; }
    void setEstePublica(bool p)           { estePublica = p; }

    // --------------------------------------------------------
    // (1p) Operator >> supraincarcat pentru citire
    // --------------------------------------------------------
    friend istream& operator>>(istream& in, CarteDeVizitaElectronica& c) {
        // Citim campurile din clasa de baza
        in >> static_cast<CarteDeVizita&>(c);

        cout << "  URL Profil (LinkedIn/website): ";
        getline(in, c.urlProfil);

        cout << "  QR Code link: ";
        getline(in, c.qrCode);

        cout << "  Format fisier (vCard/PDF/PNG): ";
        getline(in, c.formatFisier);

        cout << "  Este publica? (1=Da / 0=Nu): ";
        in >> c.estePublica;
        in.ignore();

        return in;
    }

    // --------------------------------------------------------
    // (2p) Virtualizare - afisare diferita fata de clasa de baza
    // --------------------------------------------------------
    void afiseaza(ostream& out) const override {
        out << "====== Carte de Vizita ELECTRONICA ======\n";
        out << "  Nume:         " << getNume()    << "\n";
        out << "  Telefon:      " << getTelefon() << "\n";
        out << "  Email:        " << getEmail()   << "\n";
        out << "  Companie:     " << getCompanie()<< "\n";
        out << "  URL Profil:   " << urlProfil    << "\n";
        out << "  QR Code:      " << qrCode       << "\n";
        out << "  Format:       " << formatFisier << "\n";
        out << "  Publica:      " << (estePublica ? "Da" : "Nu") << "\n";
    }

    // Operator << foloseste afiseaza() virtual
    friend ostream& operator<<(ostream& out, const CarteDeVizitaElectronica& c) {
        c.afiseaza(out);
        return out;
    }
};


// ============================================================
// Functie care demonstreaza polimorfismul (virtualizarea)
// ============================================================
void afiseazaPolimorfic(const CarteDeVizita* c) {
    c->afiseaza(cout);  // apelul corect se face la runtime
}


// ============================================================
// main - demonstrarea tuturor cerintelor
// ============================================================
int main() {
    cout << "========================================\n";
    cout << "  Gestiunea Cartilor de Vizita - C++\n";
    cout << "========================================\n\n";

    // --- Creare obiecte cu constructor cu parametri ---
    CarteDeVizita c1("Ion Popescu", "0721123456",
                     "ion.popescu@firma.ro", "Firma SRL",
                     "carton", 100, 9.0, 5.0, "business", 150.0);

    CarteDeVizita c2("Maria Ionescu", "0732654321",
                     "maria@startup.ro", "StartUp SA",
                     "plastic", 50, 8.5, 5.5, "personal", 80.0);

    CarteDeVizitaElectronica ce1("Alexandru Popa", "0756789012",
                                  "alex@tech.ro", "Tech SRL",
                                  "linkedin.com/in/alexandrupopa",
                                  "qr.tech.ro/alex",
                                  "vCard", true);

    // --- Afisare obiecte ---
    cout << "--- Carte fizica 1 ---\n" << c1 << "\n";
    cout << "--- Carte fizica 2 ---\n" << c2 << "\n";
    cout << "--- Carte electronica ---\n" << ce1 << "\n";

    // --- (1p) Demonstrare operator >= ---
    cout << "--- Comparatie cu operator >= (dupa cost) ---\n";
    if (c1 >= c2)
        cout << c1.getNume() << " are cost >= " << c2.getNume() << "\n\n";
    else
        cout << c2.getNume() << " are cost >= " << c1.getNume() << "\n\n";

    // --- Membru static ---
    cout << "Total carti de vizita create (active): "
         << CarteDeVizita::getTotalCarti() << "\n\n";

    // --- (2p) Demonstrare virtualizare / polimorfism ---
    cout << "--- Afisare polimorfica (pointer la clasa de baza) ---\n";
    CarteDeVizita* ptr1 = &c1;
    CarteDeVizita* ptr2 = &ce1;  // pointer de baza -> obiect derivat

    afiseazaPolimorfic(ptr1);   // apeleaza CarteDeVizita::afiseaza
    cout << "\n";
    afiseazaPolimorfic(ptr2);   // apeleaza CarteDeVizitaElectronica::afiseaza (virtual)
    cout << "\n";

    // --- (1p) Demonstrare operator >> (citire de la tastatura) ---
    cout << "--- Citire carte de vizita de la tastatura ---\n";
    CarteDeVizita c3;
    cout << "Introduceti datele pentru o noua carte de vizita:\n";
    cin >> c3;
    cout << "\nCarte introdusa:\n" << c3 << "\n";

    // --- Constructor de copiere ---
    CarteDeVizita c4(c3);
    cout << "--- Copie a cartii introduse ---\n" << c4 << "\n";

    cout << "Total carti active la final: "
         << CarteDeVizita::getTotalCarti() << "\n";

    return 0;
}