Liceul Teoretic de Informatică ”Grigore Moisil” Iași

PROGRAMARE ORIENTATĂ OBIECT

LISTE DUBLU INLANTUITE

Elev: POPOVICI TEODOR-ANDREI, 11A

POPA DRAGOȘ ADRIAN, 11A

Profesor: IVAȘC CORNELIA

2017-2018
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

Cuprins
Programarea orientată obiect. Noțiuni teoretice. ......................................................................................... 3
BILETUL NO. 5 ................................................................................................................................................ 4
CLASA LISTA DUBLU INLANTUITA .................................................................................................................. 5
Fișierul ”[LDI.h]” ......................................................................................................................................... 5
Fișierul ”[LDI.cpp]”...................................................................................................................................... 5
Fișierul ”[main.cpp]”................................................................................................................................... 9
Bibliografie ................................................................................................................................................... 11

2
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

Programarea orientată obiect. Noțiuni teoretice.

Programarea Orientată Obiect (POO) este o metodă de proiectare și implementare în care programele
sunt reprezentate sub forma unor colecții de obiecte care interacționează între ele prin intermediul
mesajelor.
Noțiuni fundamentale:

 Clasa: O clasă este o colecție de obiecte cu aceiași structură (caracteristici) și același

comportament (metode sau operatii)
 Constructor: Constructorul este o funcție membră specială a unei clase ce se apelează în mod
automat la crearea unui obiect
 Destructor: Destructorul este o funcție membră specială a unei clase ce apelează în mod
automat distrugerea unui obiect
 Funcţiile şi datele unei clase pot fi grupate din punct de vedere al dreptului de acces în:
o private – conţine date şi funcţii membre care pot fi folosite doar de către celelalte funcţii
aparţinând clasei respective;
o protected – similara cu private dar care dădrepturi de acces şi funcţiilor membre ale
claselor derivate din clasa respectivă;
o public – drept de acces tuturor.
 Funcțiile friend (prieten) sunt funcţii asociate unor clase care au acces la datele şi metodele
protejate ale acelor clase deşi nu sunt funcţii membre ale acelei clase. Tipuri de funcții prieten
o funcții globale
o funcții membre ale altor clase

3
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

BILETUL NO. 5

1. Concepeţi o clasă adecvată pentru implementarea structurii dinamice de date de tip listă liniară dublu
înlănţuită cu informații de tip întreg.

Clasa va conţine metodele:

a) constuctor
b) constructor de copiere
c) destructor
d) verificarea listei vide (inline)
e) căutarea unui nod de cheie dată
f) adăugarea unui nod nou la începutul listei
g) adăugarea unui nod nou la sfârşitul listei
h) ștergerea nodurilor cu o anumită informație
i) operatorul += pentru concatenarea a două liste
j) operatori supraîncărcaţi pentru citire/scriere

2. Construiţi o aplicaţie C++ care să conţină clasa ca fişier Header (.h), definitiile metodelor clasei in fisier
sursă (.cpp) si fişierul de testare a clasei (.cpp). Fişierul de testare (main) va permite selectarea operațiilor
prin intermediul unui meniu cu opţiunile corespunzătoare punctelor e - j şi cu opţiunea Ieşire. Programul de
test va utiliza liste citite atât de la tastatură cât şi din fişier.

4
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

CLASA LISTA DUBLU INLANTUITA

Fișierul ”[LDI.h]”

#include <iostream>
#include <conio.h>
#include <windows.h>
using namespace std;

//DECLARARE NOD
struct nod
{
int x;
nod *prec, *urm;
};

//CLASA LDI
class LDI
{
private:
int n;
nod *prim, *ultim;
public:
LDI();
LDI(LDI &L);
~LDI();
friend istream& operator>> (istream &is, LDI &L);
friend ostream& operator<< (ostream &os, LDI &L);
friend void operator+= (LDI &L1, LDI &L2);
void lista_vida();
int cauta(int y);
void adaugain(int y);
void adaugasf(int y);
void stergenod(int y);

};

Fișierul ”[LDI.cpp]”

#include "LDI.h"

//CONSTRCTOR
LDI::LDI()
{
prim=ultim=NULL;
}

5
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

//CONSTRUCTOR DE COPIERE
LDI::LDI(LDI &L)
{
if (L.prim)
{
prim=new nod;
*prim=*L.prim;
ultim=prim;
for (nod *p=L.prim->urm; p!=NULL; p=p->urm)
{
nod *q=new nod;
*q=*p;
ultim->urm=q;
ultim=q;
ultim->prec=q->prec;
}
ultim->urm=NULL;
}
}

//DESTRUCTOR
LDI::~LDI()
{
nod *q;
while (prim!=NULL)
{
q=prim;
prim=q->urm;
delete q;
}
}

//OPERATOR CITIRE
istream& operator>> (istream &is, LDI &L)
{
cout<<'\n';
cout<<'\n';
cout<<"Dati numarul de elemente: ";
is>>L.n;
int i;
cout<<"Elemetele listei dvs.: ";
for (i=1; i<=L.n; i++)
{
nod *p=new nod;
is>>p->x;
p->urm=NULL;
if (L.prim==NULL)
{
L.prim=L.ultim=p;
p->prec=NULL;
}
else
{
L.ultim->urm=p;
6
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE
p->prec=L.ultim;
L.ultim=p;
}
}
cout<<'\n';
return is;
}

//OPERATOR AFISARE
ostream& operator<< (ostream &os, LDI &L)
{
nod *c;
for (c=L.prim; c!=NULL; c=c->urm)
os<<c->x<<' ';
cout<<'\n';
return os;
}

//CAUTA NOD IN LISTA

int LDI::cauta(int y)
{
nod *c;
int ok=0;
for (c=prim; c!=NULL; c=c->urm)
if (c->x==y)
{
ok=1;
break;
}
return ok;
}

//ADAUGARE ELEMET LA INCEPUT

void LDI::adaugain(int y)
{
nod *c;
c=new nod;
c->x=y;
c->prec=NULL;
c->urm=prim;
prim->prec=c;
prim=c;
}

//ADAUGARE ELEMET LA SFARSIT

void LDI::adaugasf(int y)
{
nod *c;
c=new nod;
c->x=y;
c->urm=NULL;
c->prec=ultim;
ultim->urm=c;
ultim=c;
}
7
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

//VERIFICARE LISTA VIDA

void LDI::lista_vida()
{
if (prim==NULL) cout<<"Lista este vida";
else cout<<"Lista nu este vida";
}

//STERGEREA UNUI NOD DAT

void LDI::stergenod(int y)
{
nod *c, *t;
c=prim;
while (c!=NULL)
{
t=c->urm;
if (prim==ultim && c==prim && prim->x==y)
{
delete c;
prim=ultim=NULL;
}
else if (c==prim && prim->x==y)
{
prim=prim->urm;
prim->prec=NULL;
delete c;
}
else if (c==ultim && ultim->x==y)
{
ultim=ultim->prec;
ultim->urm=NULL;
delete c;
}
else if (c->x==y)
{
c->prec->urm=c->urm;
c->urm->prec=c->prec;
delete c;
}
c=t;
}
}

//OPERATOR CONCATENARE
void operator += (LDI &L1, LDI &L2)
{
nod *c, *d;
for (d=L2.prim; d!=NULL; d=d->urm)
{
c=new nod;
c->x=d->x;
c->urm=NULL;
L1.ultim->urm=c;
c->prec=L1.ultim;
L1.ultim=c;
8
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE
}
L1.n=L1.n+L2.n;
}

Fișierul ”[main.cpp]”

#include <iostream>
#include <conio.h>
#include <windows.h>
#include "LDI.h"
using namespace std;
//MENIU
void menu()
{
system("cls");
cout<<"\n\n\t Clasa Lista simpla dublu inlanuita";
cout<<"\n\n\t 1. Citire lista";
cout<<"\n\n\t 2. Afisare lista";
cout<<"\n\n\t 3. Adauga element la inceputul listei";
cout<<"\n\n\t 4. Adauga element la sfarsitul listei";
cout<<"\n\n\t 5. Stergerea nodurilor cu o informatie data";
cout<<"\n\n\t 6. Cautare nod cheie dat";
cout<<"\n\n\t 7. Concatenarea a doua liste";
cout<<"\n\n\t 0. Exit";
cout<<"\n\n\t Optiunea dvs.: ";
}
int main()
{
int op;
int cauta,inc,sf,sters;
LDI lista1,lista2;
do
{
menu();
cin>>op;
cin.get();
switch(op)
{
case 1:
{
cin>>lista1;
cout<<"Lista citita cu succes!";
getch(); break;
}
case 2:
{
cout<<"Lista 1 este: \n";
cout<<lista1;
cout<<endl;
getch(); break;
}
case 3:
{
cout<<"Nodul de adaugat la inceput: \n";
cin>>inc;
lista1.adaugain(inc);
cout<<"Nod adaugat cu succes!";
getch(); break;
}
case 4:
{
cout<<"Nodul de adaugat la sfarsit: \n";
9
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

cin>>sf;
lista1.adaugasf(sf);
break;
}
case 5:
{
cout<<"Nodul dorit de sters : \n";
cin>>sters;
lista1.stergenod(sters);
cout<<"Nodul a fost sters!";
getch(); break;
}
case 6:
{
cout<<"Nodul dorit de cautat: \n";
cin>>cauta;
if (lista1.cauta(cauta)==1) cout<<"Am gasit nodul
introdus!";
else cout<<"Nu am gasit nodul introdus! Mai incearca o
data!";
getch(); break;
}
case 7:
{
cin>>lista2;
lista1+=lista2;
cout<<"Liste concatenate cu succes!";
getch(); break;
}
}
}
while (op>=1 && op<=7);
}

10
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

Bibliografie

o http://inf.ucv.ro/~mihaiug/courses/poo/
o https://ro.wikipedia.org/wiki/Programare_orientat%C4%83_pe_obiecte

11
POPOVICI TEODOR-ANDREI
POPA DRAGOȘ-ADRIAN LISTE DUBLU INLANTUITE

12