In cadrul laboratorului 5 al Programarii Orientate pe Obiecte, vom aprofunda unul dintre cele 4 principii ale POO-ului, Polimorfismul. De asemenea, vom aborda conceptul de Agregare.

Cele 4 mari concepte ale Programarii Obiectuale sunt: Incapsulare, Polimorfism, Mostenire si Abstractizare. (Echivalent in engleza, pentru documentare suplimentara: Encapsulation, Polymorphism, Inheritance, Abstraction).

Ca referinte externe, recomandam urmatorul capitol din Absolute C++:

• Capitolul 15 (Chapter 15: Polymorphism and virtual functions, pag. 661-693)

CompileTime.cpp

#include <iostream>
using namespace std;
class OOP {
    public:
        void fct (int x) { //Avem un parametru de tip int
            cout << "x = " << x << endl;
        } 
        void fct (float x) { //Avem un parametru de tip float
            cout << "x = " << x << endl;
        }
        void fct (int x, int y) { //Avem doi parametri 
            cout << "x + y = " << x + y << endl;
        }  
};
 
int main () {
    OOP laborator;
 
    OOP.fct(10); //o sa fie apelata prima metoda (cea care are parametrul de tip int)
    OOP.fct(9.99); //o sa fie apelata a doua metoda (cea care are parametrul de tip float)
    OOP.fct(5,5); //o sa fie apelata a treia metoda (cea cu doi parametri)
 
    return 0;
}

//cod
class A {
    //lista atribute;
    //lista metode;
};
class B{
    private:
    A a;
    //alte atribute si metode
};

#include <iostream>
using namespace std;
class A {
    private:
        int atr;
    public:
        A():atr(0) { /*pana sa se intre in implementarea constructorului,
            se apeleaza pseudoconstructorul pentru atributul atr
            care aloca spatiu ptr atr si il initializeaza cu 0 */
            cout << "Constructor fara parametri" << endl;
        }
        A(const A &x):atr(x.atr) {
            /*se apeleaza pseudoconstructorul pentru atributul atr, 
            care aloca spatiu ptr atr si il initializeaza cu x.atr*/
            cout << "Constructor de copiere" << endl;
        }
        A &operator = (const A &x) {
            //nu se apeleaza pseudoconstructor pentru atr, deoarece are spatiu alocat
            cout << "Operator = " << endl;
            atr = x.atr;
            return *this;
        }
        ~A() {
            cout << "Destructor" << endl;
        }
};
class B {
    private:
        A a; // B are un atribut de tip A
        /*in mod automat se genereaza un constructor fara parametri,
        constructor de copiere, operator =, destructor */
};
int main() {
    B b;
    B c(b);
    c = b;
    return 0;
}