Ministerul Educaţiei şi Tineretului al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare Informatică şi Microelectronică
Catedra Informatică Aplicată

Lucrare de Laborator Nr.4

Disciplina: Modelarea Sistemelor

Tema: Analiza principiilor de modelare

în baza paradigmei orientate pe obiecte

A efectuat: st. gr.IA-122

Cebotari Vladimir

A verificat: dr.conf
Ştefan Marin

Chişinău 2014
Obiective:
 – de studiat şi însuşit materialul teoretic pentru evidenţierea esenţialului şi elaborarea
modelului conceptual pentru fiecare compartiment aparte (variante);
– să se elaboreze scenarii de modelare şi analiza a diferitor modele de programare pentru
propria variantă;
– să se descrie etapele si principiile de algoritmizare si rezolvare ale problemei în baza
diferitor modele OO în limbajul de programare C/C++;
– să se aplice tehnica modelării şi programării eficiente pentru diverse compartimente ale
diferitor situaţii cu diverse modele de structuri abstracte.
– Programul sa conţină o baza de date cu informaţia la aceste intrebari şi teste de verificare.

1. Noţiuni generale şi definiţii.

Paradigmă-este o mulţime de teorii, standarde şi metode pentru sistematizarea cunostintelor
acceptate de lumea savanta.
Paradigma Imperativa Se caracterizeaza printr-un model abstract al unui calculator cu o
memorie foarte mare.
Paradigma Procedurala Extinde cea anterioara cu un mecanism de abstractizare, cel al
procedurilor cu parametri.
Paradigma Orientare pe Obiecte Notiunea de baza este cea de obiect, o entitate logica,
compus din date si operatorii asupra acestora. 

Concepte fundamentale.
Ideea de baza de la care pleaca programarea orientata obiect este de a grupa structurile de date cu
operatiile care prelucreaza respectivele date. Un asemenea ansamblu poarta denumirea de obiect sau
clasa. Proiectarea de programe utilizand clase se numeste programare orientata pe obiecte (OOP).
In mod frecvent, pentru structurile de date se utilizeaza denumirea de date membre sau campuri, iar
pentru procedurile ce prelucreaza aceste date, termenul de functii membre sau metode.
In analogie cu ecuatia programarii structurate, se poate considera ca valabila urmatoarea relatie:

Date + Metode = Obiect

Diferentele dintre limbajele C si C++

Limbajul C, foarte lejer in privinta verificarii tipurilor de date, lasa programatorului o
libertate deplina. Aceasta libertate este o sursa permanenta de erori si de efecte colaterale foarte
dificil de depanat. Limbajul C++ a introdus o verificare foarte stricta a tipurilor de date. In
particular, apelul oricarei functii trebuie precedat de declararea functiei respective. Pe baza
declaratiilor, prin care se specifica numarul si tipul parametrilor formali, parametrii efectivi poat
fi verificati in momentul compilarii apelului. In cazul unor nepotriviri de tipuri, compilatorul
incearca realizarea corespondentei (matching) prin invocarea unor conversii, semnaland eroare
doar daca nu gaseste nici o posibilitate.
float maxim( float, float );
float x = maxim( 3, 2.5 );

lucru este normal, deoarece variabila x trebuie initializata inaintea lansarii in executie a functiei
main().
Intrari/iesiri in limbajul C++ Limbajul C++ permite definirea tipurilor abstracte de date prin
intermediul claselor. Clasele nu sunt altceva decat generalizari ale structurilor din limbajul C. Ele contin
date membre, adica variabile de tipuri predefinite sau definite de utilizator prin intermediul altor clase,
precum si functii membre, reprezentand metodele clasei.
Programare avansata utilizand clase .
a. Controlul accesului la clase
 Spre deosebire de limbajele orientate obiect pure, C++ permite controlul accesului la
membrii claselor. In acest scop, s-au creat trei specificatori de cotrol al accesului:
 public, membrul poate fi accesat de orice functie din domeniul declaratiei clasei;
 private, membrul este accesibil numai functiilor membre si prietene ale clasei;
 protected, similar cu private, insa accesul se extinde si la functiile membre si prietene ale
claselor derivate.
De remarcat este faptul ca o functie membra a unei clase are acces la toti membrii clasei,
indiferent de specificatorul de acces.

b. Functii si clase prietene

In paragraful precedent, am afirmat ca principiul incapsularii datelor este bine sa fie respectat
in cadrul elaborarii ierarhiei de clase. Cu toate acestea, exista situatii in care este greu sa se
respecte acest principiu. De aceea, Bjarne Stroustrup a introdus un concept menit sa rezolve si
aceste situatii particulare, pentru a oferi solutii elegante in vederea rezolvarii tuturor situatiilor
posibile. Acest concept este cel de friend, care permite practic abateri controlate de la ideea
protectiei datelor prin incapsulare. Mecanismul de friend este bine sa fie folosit numai in cazul
in care nu exista alta solutie!
Mecanismul de friend (sau prietenie) a aparut datorita imposibilitatii ca o metoda sa fie
membru a mai multor clase.
Functiile prietene sunt functii care nu sunt metode ale unei clase, dar care au totusi acces la
membrii privati ai acesteia. Orice functie poate fi prietena a unei clase, indiferent de natura
acesteia.
Sintaxa declararii unei functii prietene in cadrul declaratiei unei clase este urmatoarea:

friend NumeFunctie

 Clase virtuale
Utilizarea mostenirii multiple se poate complica odata cu cresterea dimensiunii ierarhiei de
clase. O situatie care poate apare este derivarea din doua clase de baza, Clasa1 si Clasa2, care la
randul lor sunt derivate dintr-o clasa comuna, ClasaDeBaza. In acest caz, noua clasa,
ClasaNoua, va contine datele membre ale clasei ClasaDeBaza duplicate. Daca prezenta acestor
date duplicate este utila, ele pot fi distinse evident cu ajutorul operatorului de rezolutie, ::.
Totusi, in cele mai multe cazuri, aceasta duplicare nu este necesara si duce la consum inutil de
memorie. De aceea, in C++ a fost creat un mecanism care sa evite aceasta situatie, prin
intermediul conceptului de clasa virtuala. Sintaxa este:

class NumeClasaDerivata : SpecificatorAcces virtual NumeClasaDeBaza

 Aceasta declaratie nu afecteaza clasa in cauza, ci numai clasele derivate din aceasta. Astfel,
clasele Clasa1 si Clasa2 considerate vor fi declarate virtuale. Trebuie mentionat faptul ca
declararea virtual a acestor clase va afecta definirea constructorului clasei ClasaNoua, deoarece
compilatorul nu poate hotari care date vor fi transferate catre constructorul ClasaDeBaza,
specificate de constructorii Clasa1 si Clasa2. Constructorul ClasaNoua va trebui modificat astfel
incat sa trimita datele pentru constructorul ClasaDeBaza. De asemenea, trebuie precizat ca intr-o
ierarhie de clase derivate, constructorul clasei virtuale este intotdeauna apelat primul.

5.Listingul programului:
#include <iostream.h>
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>

int poly[10],x,y;
char c;

class Gimnast
{
//Declararea tipului de variabile, "public" vor fi vizibile din tot programul
public:
// Declararea functiior ca variabile a clasei
void DrawHead ( int x, int y, double Radius );
void DrawLeftEye ( int x, int y, double Radius );
void DrawRightEye ( int x, int y, double Radius );
void DrawNose ( int x, int y );
void DrawMounth ( int x, int y, int StartAngle, int EndAngle, int Radius );
void DrawBody ( int x, int y );
void DrawRightHand ( int x, int y );
void DrawLeftHand ( int x, int y );
void DrawRightFoot ( int x, int y );
void DrawLeftFoot ( int x, int y );

void DrawRightHandMJ ( int x, int y );

void DrawLeftHandMJ ( int x, int y );
void DrawRightFootMJ ( int x, int y );
void DrawLeftFootMJ ( int x, int y );

void DrawRightHandTop ( int x, int y );

void DrawLeftHandTop ( int x, int y );
void DrawRightFootTop ( int x, int y );
void DrawLeftFootTop ( int x, int y );

};
//Functiile declarate in clasa, si corpul acestora. Declararea se face ca apel a functiei sau
variabilei publice dintr-o clasa

void Gimnast::DrawHead( int x, int y, double Radius )

{
//Desenarea capului
circle( x, y, 25 );//head
}
void Gimnast::DrawLeftEye( int x, int y, double Radius )
{
//Ochiul sting
circle( x-10, y-5, 5 );
}
 void Gimnast::DrawRightEye( int x, int y, double Radius )
{
//Ochil drept
circle( x+10, y-5, 5 );
}
void Gimnast::DrawNose ( int x, int y )
{

line( x, y-3, x, y+5 );

}
void Gimnast::DrawMounth( int x, int y, int StartAngle, int EndAngle, int Radius )
{
arc( x, y+5, 220, 320, 10 );
}
void Gimnast::DrawBody( int x, int y )
{
//Corpul "gimnastului" coordonatele carui sunt plasate intr-o lista
// x y
poly[0]=x-40; poly[1]=y+25;
poly[2]=x+40; poly[3]=y+25;
poly[4]=x+25; poly[5]=y+150;
poly[6]=x-25; poly[7]=y+150;
poly[8]=poly[0]; poly[9]=poly[1];
drawpoly(5,poly);
}
void Gimnast::DrawLeftHand( int x, int y )
{
//Mina stinga
// x y
poly[0]=x-40; poly[1]=y+25;
poly[2]=x-80; poly[3]=y+105;
poly[4]=x-70; poly[5]=y+108;
poly[6]=x-38; poly[7]=y+32;
poly[8]=poly[0]; poly[9]=poly[1];

drawpoly(5,poly);
}
void Gimnast::DrawRightHand( int x, int y )
{
//Mina dreapta
// x y
poly[0]=x+40; poly[1]=y+25;
poly[2]=x+80; poly[3]=y+105;
poly[4]=x+70; poly[5]=y+108;
poly[6]=x+38; poly[7]=y+32;
poly[8]=poly[0]; poly[9]=poly[1];

drawpoly(5,poly);
}
void Gimnast::DrawLeftFoot( int x, int y )
{
//Piciorul sting
 rectangle( x-20,y+150,x-10,y+200 );
}
void Gimnast::DrawRightFoot( int x, int y )
{
//Piciorul drept
rectangle( x+10,y+150,x+20,y+200 );
}

//*****************************************************************
//Middle jump

6.Concluzie:
Paradigma de programare orientată-obiect stabileşte modul de conceptualizare a lumii
reale şi a problemelor concrete prin utilizarea obiectelor, ca unităţi universale de definire a unor
aspecte ale realităţii. Clasele şi obiectele, ce reprezintă o instanţă ale acestora, sunt modele
simplificate ale unei entităţi concrete sau abstracte, proces, fenomen, etc. POO operează cu
modele şi relaţiile dintre acestea.

In lucrarea respectiva de laborator am facut cunostinta cu Paradigma de programare orientata pe

obiect si am ajuns la concluzia ca PPO a aparut ca o necesitate de a trece le conceptul nou de
percepere a realitatii ,inclusiv a logicii de programare ,scotind in prim plan obiectul actiunii si
subordonind actiunile acestuia ,caracteristicile si proprietatile legate de el precum si apropiere
pe cit se poate de posibil de esenta problemei nu de caracterul limbajului sau a masinii pe care
este realizat.