Sunteți pe pagina 1din 8

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică şi Microelectronică


Catedra Inginerie, Software si Automatică

RAPORT
la lucrarea de laborator nr. 7

la Programarea în limbajul C++

Tema: Șabloane

Varianta: 1

A efectuat:

A verificat:

Chișinău - 2017
Tema: Șabloane

Scopul lucrării:
 Studierea necesității șabloanelor
 Studierearegulilor de definire și utilizare a șabloanelor
 Studierea specializării șabloanelor
 Studierea potențialelor probleme rezolvate cu ajutorul șabloanelor

Întrebări de control:
1. Ce reprezintă prin sine șabloanele?
Un tip de date generic care ne permite să scrii un cod, care nu este legat de un tip anumit de date
precum int double sau float, ci unul generic care poate sa fie orice tip din cele specificate. Cel mai des,
şabloanele sunt utilizate pentru crearea container şi algoritmi abstracţi.

2. Care sunt avantajele utilizării șabloanelor?


Micşorează codul de ieşire, care duce la, micşorarea cantităţii de erori, micşorează introducerea
modificărilor în cod şi micşorează prezentarea programelor în general, aşa cum se micşorează
calitatea tipurilor şi funcţiilor date.
3. Pentru ce se utilizează specializarea?
Reprezintă înscrierea încă a unei funcţii pentru un tip determinat. În cazul funcţiilor această de
obicei nu este o funcţie şablon cu acelaşi nume şi cu parametri predefiniţi. Această funcţie poate
avea un avantaj mai mare decât şabloanele

4. Ce poate fi un șablon?
Orice funcție sau clasă.

5. Care sunt problemele utilizării șabloanelor?


Șabloanele lucrează excelent cu tipul de date int, float însă creează unele probleme la șiruri.

6. Utilizarea șabloanelor duce la economia memoriei?


Șabloanele nu micșorează compilarea modulului, mai degrabă chiar invers, dar simțitor micșorează
codul de ieșire.

7. Poate o clasă șablon să moștenească una obișnuită și invers?


Da, sunt posibile ambele cazuri.

Sarcinile individuale:
а) Creaţi o funcţie şablon, care schimbă ordinea elementelor în felul următor: prima parte a listei se
amestecă la urmă, dar a doua la început. De exemplu: 1 2 3 4 5 6 - 4 5 6 1 2 3. Funcţia trebuie să
lucreze cu masive de lungimi diferite. Dacă numărul de elemente este impar, atunci elementul mijlociu
nu trebuie de prelucrat.

Listing - ul programului:
#include <iostream>
#include <string.h>

using namespace std;


template <typename T>
T Mod(T *x, int size)
{
T *y;
int half;
int second_half;
int aux = 0;
int impar = 0;
int par = 0;
system("clear");
cout << "Sirul initial - Sirul modificat: " << endl;
//afisam sirul initial
for(int i = 0; i < size; i++)
cout << " " << x[i];
//aflam daca nr de elem este par sau impar
if(size % 2 == 0)
par++;
else
impar++;
//aflam indexul cu care se termina prima jum
if(impar == 1)
half = ((size-1)/2);
else
half = (size/2);
//copiem prima jum in sir auxiliar
y = new T [half];
for(int i = 0; i < half; i++)
y[i] = x[i];
//aflam indexul cu care se incepe a doua jumatate
if(impar == 1)
second_half = (half + 2) - 1;
else
second_half = (half + 1) - 1;
//copiem a doua jumatate in prima jumatate a sirului
for(int i = second_half; i < size; i++)
x[aux++] = x[i];
//copiem prima jumatate din sirul auxiliar in a doua jum a
sirului de baza
aux = 0;
for(int i = second_half; i < size; i++)
x[i] = y[aux++];
cout << " ->";
//afisam sirul permutat
for(int i = 0; i < size; i++)
cout << " " << x[i];
cout << endl;
delete [] y;
return 0;
}

int main()
{
int *a;
int size;
cout << "Dati numarul de elemente: " << endl;
cin >> size;
a = new int[size];
cout << "Introduceti elementele: " << endl;
for(int i = 0; i < size; i++)
cin >> a[i];
Mod<int>(a,size);
delete [] a;
}

În urma execuției programului am obținut:


b) Creaţi clasa parametrizată Stack. Clasa trebuie să conţină constructorii, destructorii, şi deasemenea
funcţiile push, pop, empty, full şi operatorii de intrare/ieşire. Pentru alocarea memoriei să se utilizeze
operatorul new.
Listing – ul programului:

#include <iostream>

using namespace std;

#define MAX 100


template <class T>
class Stack {
public:
T *A;
int top;
public:
Stack();//constructorul
void Push(int x);
void Pop();
int IsEmpty();
int isFull();
~Stack();
//supraincarcarea operatorului de iesire
friend ostream &operator << (ostream& os, const Stack<T>& s)
{
os << "Stack: ";
for(int i = 0; i <= s.top; i++)
os << " " << s.A[i];
os << endl;
return os;
}
friend istream &operator >> (istream& os, const Stack<T>& s)
{
cout << "Adaugati in stack cu functia Push()" << endl;
return os;

}
};

template <typename T>


Stack<T>::Stack()
{
A = new T[MAX];
top = -1;
}

template<typename T>
void Stack<T>::Push(T x)
{
if(top == MAX -1)
{
cout << "Error: stack overflow" << endl;
return;
}
A[++top] = x;
}

template <typename T>


void Stack<T>::Pop()
{
if(top == -1) {
cout << "Error: No element to pop" << endl;
return;
}
top--;
}

template <typename T>


int Stack<T>::IsEmpty()
{
if(top == -1) return 1;
return 0;
}

template <typename T>


int Stack<T>::isFull()
{
if(top == MAX -1)
{
cout << "Error: stack overflow" << endl;;
return 1;
}
return 0;
}

template <typename T>


Stack<T>:: ~Stack()
{
delete [] A;
}
int main()
{
Stack<int> a;
system ("clear");
a.Push(2);
a.Push(5);
a.Push(10);
cout << a;
a.Pop();
a.Push(12);
cout << a;
//cin >> a;
}

În urma execuției acestui program am obținut:

Concluzie:
Pe parcursul acestei lucrări de laborator am studiat necesitatea utilizării șabloanelor și regulile de
definire a acestora. Am studiat specializarea șabloanelor și am făcut cunoștință cu potențialele probleme
rezolvate cu ajutorul lor.
Efectuînd această lucrare am îndeplinit două sarcini individuale, pentru care am realizat o funcție
șablon care schimbă ordinea elementelor și o clasă parametrizată Stack. Îndeplinind aceste sarcini mi-am
îmbunătățit tehnicile de lucru cu șabloanele în limbajul de programare C++.