În C++, constructorii sunt funcții speciale ale unei clase care sunt apelate atunci când un obiect
al clasei este creat. Există mai multe tipuri de constructori, fiecare având un rol specific:
Constructor implicit (default constructor): Constructor fără parametri.
Constructor parametrizat (parameterized constructor): Constructor care ia unul sau mai mulți
parametri.
Constructor de copiere (copy constructor): Constructor care creează un nou obiect ca o copie a
unui obiect existent.
Constructor implicit:Example() {
x = 0;
y = 0;
cout << "Default constructor called" << endl;
}
Constructor parametrizat:Example(int a, int b) {
x = a;
y = b;
cout << "Parameterized constructor called" << endl;
}
Constructor de copiere:Example(const Example& other) {
x = other.x;
y = other.y;
cout << "Copy constructor called" << endl;
}
Funcțiile virtuale în C++ sunt metode declarate în clasa de bază cu cuvântul cheie virtual,
permițând astfel claselor derivate să le suprascrie. Aceste funcții asigură polimorfismul dinamic,
astfel încât apelul funcției să fie determinat la runtime în funcție de tipul real al obiectului pe care
îl referențiază un pointer sau o referință la clasa de bază.
#include <iostream>
using namespace std;
class Base {
public:
virtual void show() {
cout << "Base class show() method" << endl;
}
};
class Derived : public Base {
public:
void show() override {
cout << "Derived class show() method" << endl;
}
};
int main() {
Base* basePtr;
Derived derivedObj;
basePtr = &derivedObj;
// Apel funcție virtuală
basePtr->show(); // Output: "Derived class show() method"
return 0;
}
Persoana:
Atribute: nume, varsta
Metode: afisareInformatii()
Elev (derivă din Persoana):
Atribute: notaMedie
Metode: afisareInformatii()
Profesor (derivă din Persoana):
Atribute: materie
Metode: afisareInformatii()
Diagrama UML:
plaintext
Copiază codul
+-----------------+
| Persoana |
+-----------------+
| - nume: string |
| - varsta: int |
+-----------------+
| + afisareInformatii(): void |
+-----------------+
^
|
+-----------------+ +-----------------+
| Elev | | Profesor |
+-----------------+ +-----------------+
| - notaMedie: float| | - materie: string|
+-----------------+ +-----------------+
| + afisareInformatii(): void | + afisareInformatii(): void |
+-----------------+ +-----------------+
Cod C++:
cpp
Copiază codul
#include <iostream>
#include <string>
using namespace std;
class Persoana {
protected:
string nume;
int varsta;
public:
Persoana(const string& n, int v) : nume(n), varsta(v) {}
virtual void afisareInformatii() {
cout << "Nume: " << nume << ", Varsta: " << varsta << endl;
}
};
class Elev : public Persoana {
private:
float notaMedie;
public:
Elev(const string& n, int v, float nm) : Persoana(n, v), notaMedie(nm) {}
void afisareInformatii() override {
Persoana::afisareInformatii();
cout << "Nota Medie: " << notaMedie << endl;
}
};
class Profesor : public Persoana {
private:
string materie;
public:
Profesor(const string& n, int v, const string& m) : Persoana(n, v), materie(m) {}
void afisareInformatii() override {
Persoana::afisareInformatii();
cout << "Materie: " << materie << endl;
}
};
int main() {
Persoana* persoana;
Elev elev("Ion Popescu", 16, 9.5);
Profesor profesor("Maria Ionescu", 45, "Matematica");
persoana = &elev;
persoana->afisareInformatii(); // Output: Nume: Ion Popescu, Varsta: 16, Nota Medie: 9.5
persoana = &profesor;
persoana->afisareInformatii(); // Output: Nume: Maria Ionescu, Varsta: 45, Materie:
Matematica
return 0;
}
Explicații:
Clasa Persoana:
Atribute: nume și varsta.
Metodă virtuală: afisareInformatii(), care afișează informațiile despre persoană.
Clasa Elev derivată din Persoana:
Atribut suplimentar: notaMedie.
Suprascrierea metodei afisareInformatii() pentru a afișa și nota medie.
Clasa Profesor derivată din Persoana:
Atribut suplimentar: materie.
Suprascrierea metodei afisareInformatii() pentru a afișa și materia predată.
Polimorfism:
Pointerul Persoana* poate referi un obiect de tip Elev sau Profesor.
Apelul metodei afisareInformatii() va executa metoda suprascrisă corespunzătoare tipului real al
obiectului referit.