OOP este o metoda de implementare in care:
a) Obiectele sunt elementele de baza,
b) Orice obiect este o instanta a unei clase,
c) Clasele sunt legate (asociate) unele cu altele prin mostenire.
Un limbaj este orientat obiect daca:
a) Utilizeaza obiecte,
b) Obliga obiectele sa apartina unei clase,
c) Permite mostenirea.
Limbajul C++ ofera notiunea de clasa, prin care se pot forma ierarhii, deci putem vorbi de o programare orientata obiect (OOP
OOP inseamna realizarea unor programe alcatuite dintr-o multime de obiecte care interactioneaza pentru a rezolva problema propusa, si permite reutilizarea elementelor descrise (a interfetei si a codului).
Un obiect are o stare si un comportament (operatii descrise in interfata obiectului) aceste doua componente fiind definite prin datele membru (variabile de instanta) si respectiv prin functiile membru (metode).
OOP utilizeaza ormatoarele concepte:
|
clasa |
implementarea unui TAD, |
|
obiectul |
instanta unei clase, |
|
metoda |
mesajul prin care se asigura interfata (operatiile). |
OOP are urmatoarele caracteristici (proprietati) de baza:
|
incapsularea |
gruparea datelor si a operatiilor definite pentru acestea, precum si protectia acestor date (ele neputand fi accesate decat prin functiile membru). |
|
mostenirea |
pastrarea elementelor (date si functii ale) unei clase (de baza), cu definirea de noi elemente construind o noua clasa (derivata), formand in felul acesta ierarhii de clase. Mostenirea poate fi si multipla daca o clasa mosteneste mai multe clase. |
|
polimorfism |
- redefinirea (supraincarcarea) operatiilor (functiilor). Intr-o ierarhie pot fi mai multe functii cu acelasi nume, deci va fi efectuata operatia corespunzatoare obiectului care o apeleaza. Determinarea operatiei se poate face la compilare (legare statica) sau la executie (legare dinamica, prin functii vituale |
O clasa se declara ca si o structura, inlocuind cuvantul struct cu class. Protectia datelor se defineste scriind modificatorul dorit (private, protected sau public) urmat de ':'.
Descrierea unei clase contine atat datele membru (variabilele de instanta) cat si functiile membru (metodele), precizand pentru acestea gradul de protectie, astfel:
class Nume_clasa
unde:
Modificator_de_protectie I , private fiind implicit,
private nu permite accesul din afara clasei,
protected permite accesul din clasele derivate,
public permite accesul din afara clasei;
Lista_membrii I
Datele de tip private ( ) pot fi accesate doar de functiile membru sau functii prietene (friend). O functie membru a unei clase poate fi functie prietena a altei clase, iar daca toate sunt prietene, atunci se poate declara clasa prietena (friend). Vezi C8
Fiecare obiect al unei clase detine un set de date membru (variabile de instanta).
Functiile membru publice pot fi utilizate din orice functie din program, pe cand cele private doar din functiile membru ale clasei.
Definirea functiilor membru (metodelor) se poate realiza:
a) imediat (complet, antet plus corp) in definitia clasei (ca functie inline) daca functia nu contine multe instructiuni si nu contine structuri repetitive (apelul nu se face prin salt cu revenire), astfel:
class Nume_clasa antet corp
b) ulterior (daca a fost declarat in definitia clasei doar prototipul functiei), utilizand operatorul de rezolutie (de scop) astfel:
Tip_functie Nume_clasa Nume_metoda operatorul de rezolutie
// corpul functiei
Exemplu:
// C l a s a P u n c t
----- ----- --------- ----- -----
# include <conio.h>
# include <iostream.h>
class Punct
Punct (float x0, float y0)
Punct (Punct& P)
void CitP (char* Mes);
void TipP (char* Mes);
Punct& SimPb ( );
};
void Punct::CitP (char* Mes)
void Punct::TipP (char* Mes)
Punct& Punct::SimPb( )
void main (void)
Un obiect este o instanta a unei clase (o variabila de tipul clasei). Fiecare obiect apartine unei singure clase (aceasta putand avea mai multe obiecte).
Obiectele unei clase se declara astfel:
Clasa Lista_Obiecte
Exemplu:
// Obiecte P u n c t
----- ----- --------- ----- -----
# include <conio.h>
# include <iostream.h>
class Punct ;
void main (void)
Alocarea (si initializarea) obiectelor se face cu o functie membru specifica numita constructor (cu numele Clasa) iar dealocarea cu o functie destructor (cu numele ~Clasa).
Exemplu:
Constructori - Destructori
# include <dos.h>
# include <math.h>
# include <conio.h>
# include <graphics.h>
# include <iostream.h>
# define Cale 'c:BorlandCBgi'
class Grafic
Grafic( )
};
class Punct
Punct (float x0, float y0)
Punct (Punct& P)
Punct (int, int, int);
Punct ();
int X0 ()
int Y0 ()
Punct& Transl(Punct&);
};
Punct:: Punct(int x0,int y0,int c)
Punct::~Punct( )
Punct& Punct::Transl(Punct& T)
void main (void)
getche();
Componentele claselor (datele si functiile membru) se refera prin operatorul sau >, ca si in cazul unei structuri. Functiile membru refera direct componentele clasei (fara acesti operatori, utilizand poinetrul this declarat automat ca pointer la obiectul curent).
Exemplu:
Operatorii si >
# include <dos.h>
# include <math.h>
# include <conio.h>
# include <graphics.h>
# include <iostream.h>
# define Cale 'c:BorlandCBgi'
class Grafic
Grafic( )
};
class Punct
Punct (float x0, float y0)
Punct (const Punct& P)
Punct (int, int, int);
~Punct ();
Punct* Init (float x0, float y0)
int X0 ()
int Y0 ()
Punct* Transl(const Punct*);
};
Punct:: Punct(int x0,int y0,int c)
Punct::~Punct( )
Punct* Punct::Transl(const Punct* T)
void main (void)
// Sterge P
delete M; getche();
delete C; getche();
Un obiect este creat de un constructor al clasei si este sters (distrus) de catre destructor.
Constructorii permit initializarea obiectelor cu (mai multe) functii membru omonime (avand acelasi nume cu clasa si care difera prin lista parametrilor formali), fara a returna o valoare. Constructorul este apelat automat la crearea unui obiect. O clasa trebuie sa contina cel putin doi constructori:
un constructor implicit (fara parametri, care initializeaza obiectele cu o valoare implicita),
un constructor de copiere (care initializeaza cu valoarea unui obiect existent, de acelasi tip).
Exemplu:
Constructori String
# include <Conio.h>
# include <String.h>
# include <Iostream.h>
class String ;
String::String ()
String::String (const String& S)
String::String (const char* S)
String& String::operator=(const String& S)
return *this;}
String::~String ()
int String::Length ()
void String::Print ()
void main ()
Antetul unui constructor al unei clase ce contine ca date membru obiecte alte altor clase este de forma:
Clasa Lista_par_formali Obiect Lista_par_formali Obiectn Lista_par_formalin
Exemplu:
#include <stdio.h>; #include <conio.h>; #include <iostream.h>;
class P3D
P3D (float x0, float y0, float z0)
void Tip()
};
class Cerc ;
Cerc (float x0, float y0, float z0) : x_y_r(x0,y0,z0)
Cerc (P3D C)
Cerc (const Cerc & C0)
void Tip()
};
void main (void)
Destructorii realizeaza automat dealocarea obiectelor globale la sfarsitul programului, iar a celor locale la sfarsitul functiei. Obiectele alocate dinamic (cu new) se vor dealoca cu operatorul delete. Numele destructorului este compus din caracterul urmat de numele clasei ( Clasa ). Destructorii nu returneaza o valoare.
Exemplu:
#include <iostream.h>;
class Cerc
~Cerc ()
void Tip ()
};
void main (void)
// Rezultatele afisate:
Alocare
C(1,2,3)
Dealocare
Obiecte alocate dinamic (operatorul delete)
#include <string.h>;
#include <iostream.h>;
class Natural ;
Natural::Natural(char* Nr)
Natural::~Natural()
void f(Natural x)
Natural x('123');
void main (void)
// Rezultatele afisate:
Constr.Ob. 123
*Start*
Constr.Ob. 456
Constr.Ob. 789
f(x)
Distr.Ob. 789
*Stop*
Distr.Ob. 456
Distr.Ob. 123
|
