Ministerul Educaţiei, Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul Informatică și Ingineria Sistemelor

RAPORT
Lucrarea de laborator nr.4
la Programarea Calculatoarelor
Varianta 2

A efectuat: st. gr.

A verificat:

Chişinău -2024
 LUCRARE DE LABORATOR NR. 4

Tema: Polimorfism. Funcţii virtuale. Clase abstracte

Scopul lucrării:
 Studierea polimorfismului;
 Studierea principiilor legăturii întîrziate;
 Studierea funcţiilor virtuale;
 Polimorfismul ad-hoc;
 Realizarea funcţiilor virtuale;
 Studierea claselor abstracte.

Noţiuni de bază :
Cuvântul polimorfism provine din greacă şi aproximativ se traduce ca „multe forme” (poly –
multe, morphos - formă). În viaţă tipurile polimorfe – sunt acelea, care se caracterizează printro
diversitate de forme sau caracteristici. În chimie legăturile polimorfe se pot cristaliza, cel puţin,
în două forme diferite (de exemplu, carbonul are două forme cristaline –grafitul şi diamantul).
Din alt punct de vedere, inginerul TI este în primul rând om, şi apoi este inginer (principiul de
substituţie).
În limbajele de programare un obiect polimorf – este o entitate (variabilă, argumentul funcţiei),
care păstrează, în timpul executării programului, valorile diferitor tipuri. Funcţiile polimorfe –
sunt acele funcţii, care au argumente polimorfe.
În С++ polimorfismul rezultă firesc din :
 Relaţia "a fi exemplar";
 Mecanismul de expediere a mesajelor;
 Moştenire;
 Principiul de substituţie.
Unul din avantajele principale a programării orientate pe obiecte, constă în posibilitatea de a
combina aceste mijloace. În rezultat se obţine un set bogat de exemple tehnice împreună cu
utilizarea repetată a codului. Variabila polimorfă: conţine valoarea, care se referă la diferite tipuri
de date. Variabilele polimorfe realizează principiul de substituire. Cu alte cuvinte, cu toate că
pentru asemenea variabile există un tip de date aşteptat, tipul real poate fi un subtip a tipului
aşteptat. În C++ variabilele polimorfe există numai ca referinţe şi pointeri. Funcţiile polimorfe –
reprezintă una din cele mai puternice tehnici de programare obiect orientate. Ele permit
concomitent să scrii cod la un nivel înalt de abstractizare şi apoi sa-l utilizezi într-o situaţie
concretă. De obicei programatorul execută ajustarea codului cu ajutorul transmiterii mesajelor
adăugătoare destinatarului, care utilizează metoda. Aceste metode adăugătoare, deseori nu sunt
legate cu clasa la nivelul abstractizării metodei polimorfe. Ele sunt metode virtuale, care se
definesc pentru clasele de nivel mult mai jos.
Sarcina:Varianta 2
Creaţi clasa abstractă de bază Figure cu funcţia virtuală - aria. Creaţi clasele derivate Square,
Circle, Triangle, Trapeze în care funcţia dată este predefinită. În funcţia main determinaţi
masivul de pointeri la clasa abstractă, cărei i se atribuie adresele obiectelor claselor derivate. Aria
trapezului: S=(a+b)h/2

Codul programului:
#include <iostream> }
#include <vector>
void inputDimensions() override {
class Figure { std::cout << "Introduceți lungimea
laturii pentru pătrat: ";
public:
std::cin >> side;
virtual float calculateArea() const = 0;
}
virtual void printDetails() const = 0;
};
virtual void inputDimensions() = 0; //
Adăugăm o funcție virtuală pentru
introducerea datelor
class Circle : public Figure {
virtual ~Figure() {}
private:
};
float radius;

class Square : public Figure {

public:
private:
Circle(float radius) : radius(radius) {}
float side;

float calculateArea() const override {

public:
return 3.14159 * radius * radius;
Square(float side) : side(side) {}
}

float calculateArea() const override {

void printDetails() const override {
return side * side;
std::cout << "Cerc - Rază: " << radius
} << ", Arie: " << calculateArea() <<
std::endl;
}
void printDetails() const override {
std::cout << "Pătrat - Latură: " << side
<< ", Arie: " << calculateArea() << void inputDimensions() override {
std::endl;
 std::cout << "Introduceți raza pentru private:
cerc: ";
float base1;
std::cin >> radius;
float base2;
}
float height;
};

public:
class Triangle : public Figure {
Trapeze(float base1, float base2, float
private: height) : base1(base1), base2(base2),
height(height) {}
float base;
float height;
float calculateArea() const override {
return (base1 + base2) * height / 2.0;
public:
}
Triangle(float base, float height) :
base(base), height(height) {}
void printDetails() const override {
float calculateArea() const override { std::cout << "Trapez - Bază1: " <<
base1 << ", Bază2: " << base2 << ",
return 0.5 * base * height;
Înălțime: " << height
}
<< ", Arie: " << calculateArea()
<< std::endl;

void printDetails() const override { }

std::cout << "Triunghi - Bază: " <<

base << ", Înălțime: " << height << ", Arie: "
void inputDimensions() override {
<< calculateArea() << std::endl;
std::cout << "Introduceți baza1, baza2
}
și înălțimea pentru trapez: ";
std::cin >> base1 >> base2 >> height;
void inputDimensions() override {
}
std::cout << "Introduceți baza și
};
înălțimea pentru triunghi: ";
std::cin >> base >> height;
int main() {
}
std::vector<Figure*> figures;
};

// Introducerea datelor pentru fiecare

class Trapeze : public Figure {
figură
 for (int i = 0; i < 4; ++i) { std::cout << "Opțiune nevalidă.
Încercați din nou." << std::endl;
char choice;
--i; // Decrementăm contorul
std::cout << "Introduceți dimensiunile
pentru a repeta introducerea datelor pentru
pentru figura " << i + 1 << " (s - pătrat, c -
figura curentă
cerc, t - triunghi, z - trapez): ";
continue;
std::cin >> choice;
}

Figure* figure = nullptr;

figure->inputDimensions();
figures.push_back(figure);
switch (choice) {
}
case 's':
figure = new Square(0.0);
// Afișarea detaliilor și ariei pentru fiecare
break;
figură
case 'c':
for (const auto& figure : figures) {
figure = new Circle(0.0);
figure->printDetails();
break;
}
case 't':
figure = new Triangle(0.0, 0.0);
// Eliberarea resurselor (apelul
break; destructorilor)

case 'z': for (const auto& figure : figures) {

figure = new Trapeze(0.0, 0.0, delete figure;

0.0);
}
break;
default:
return 0;
}
Rezultatele programului:

Concluzie:
În cadrul acestei implementări, am creat o ierarhie de clase pentru diverse figuri
geometrice folosind conceptele de programare orientată pe obiect în limbajul C++.
Am folosit o clasă abstractă de bază, Figure, cu funcții virtuale pure pentru arie și
pentru introducerea dimensiunilor, și am implementat clasele derivate Square,
Circle, Triangle, Trapeze.
Am adăugat funcționalitatea de a citi dimensiunile de la tastatură pentru fiecare
figură și am făcut posibilă gestionarea acestora într-un vector de pointeri la clasa
de bază. Utilizarea funcțiilor virtuale permite ca metoda specifică fiecărei clase
derivate să fie apelată corect, indiferent de tipul de obiect din vector.
Implementarea reflectă utilizarea polimorfismului, moștenirii și funcțiilor
virtuale pentru a crea un sistem flexibil și extensibil. Acesta permite adăugarea
facilă a altor clase derivate pentru alte figuri geometrice fără a modifica codul
existent. Aceste concepte sunt fundamentale în dezvoltarea de software orientat pe
obiect, permițând organizarea, structurarea și extinderea codului într-un mod
eficient și ușor de întreținut.