Sunteți pe pagina 1din 10

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică si Microelectronică

Lucrarea de laborator Nr.7


la disciplina Programarea orientată pe obiecte

Tema: Şabloane

Varianta 10

A efectuat

A verificat
Tema: Şabloane

Scopul lucrării:
 Studierea necesităţii şabloanelor;
 Studierea regulilor de definire şi utilizare a şabloanelor;
 Studierea specializării şabloanelor;
 Studierea potenţialelor probleme rezolvate cu ajutorul şabloanelor;

Întrebări de control:

Ce reprezinta sabloanele ?
- un mecanism ce permite să scrii un algoritm, care nu este legat de un tip anumit. Cel mai des,
şabloanele sunt utilizate pentru crearea container şi algoritmi abstracţi.
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.
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.
Ce poate fi un şablon?
– orice functie sau clasa
Care sunt problemele utilizării şabloanelor?
- sabloanele lucreaza bine cu tipurile de date int , float insa creeaza unele probleme la siruri.
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
Poate o clasă şablon să moştenească una obişnuită şi invers?
– DA.
Sarcina:
Varianta 10
а) Creaţi o funcţie şablon, de sortare a elementelor unui masiv în descreştere prin metoda de
introducere. Funcţia trebuie să lucreze cu masive de lungimi diferite.
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
using namespace std;
template<typename T>
T* sortare_descrescator(int n, T t[])
{
T key;
int i, j;
for (i = 1; i < n; i++)
{
key = t[i];
j = i-1;
while (j >= 0 && t[j] < key)
{
t[j+1] = t[j];
j = j-1;
}
t[j+1] = key;
}
return t;
}
int main(){
int a[3]={2,1,9};
float b[4]={3.0,1.2,4.8,1.9};
sortare_descrescator<int >(3,a);
sortare_descrescator<float>(4,b);
for (int i=0; i <3 ; i++)
{printf("%d ", a[i]);}
printf("\n");
for (int i=0; i < 4; i++)
{printf("%f ", b[i]);}
return 0;
}

b) Creaţi clasa parametrizată MultiMap – listă multi-asociativă, care conţine cheia câmpurilor şi
lista de valori. Adică, unei chei pot sa-i aparţină mai multe valori. Clasa trebuie să conţină
constructorii, destructorii şi funcţiile add, removeByKey, getLength, getByKey, getByValue, şi
operatorii [] şi de intrare/ieşire.
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <conio.h>
using namespace std;
template<typename T1,typename T2,typename T3>
class MultiMap
{
private:
T1 key[100];
T2 listvalue[100][100];
T3 length[100];
int n;
public:
MultiMap(T1 a[10],T2 b[10][10],T3 c[10],int n1)
{
for(int i=0;i<=n1;i++)
{
key[i]=a[i];
length[i]=c[i];
for(int j=0;j<=length[i];j++)
{
listvalue[i][j]=b[i][j];
}
}
n=n1;
}
MultiMap()
{
cout<<endl<<"Creare obiect";
}

~MultiMap()
{
delete [] key;
delete []listvalue;
delete [] length;
}
void add(T1 key1,T2 k[],T3 lung)
{
key[n]=key1;
length[n]=lung;
for(int i=0;i<lung;i++)
{
listvalue[n][i]=k[i];
}
n++;
}
void ShowMap()
{
cout<<"Multimap Date";
for(int i=0;i<n;i++)
{
cout<<endl<<"Key = "<<key[i];

cout<<" Lista de valori : ";


for(int j=0;j<length[i];j++)
{
cout<<" "<<listvalue[i][j];
}
}
}
void removebykey(T1 cheie)
{
for(int i=0;i<n;i++)
if(cheie==key[i])
{
for(int j=i;j<n-1;j++)
{
key[j]=key[j+1];
length[j]=length[j+1];
for(int k=0;k<length[j+1];k++)
{
listvalue[j][k]=listvalue[j+1][k];
}
}n--;
}
}
int getLength(T1 cheie)
{
for(int i=0;i<n;i++)
if(cheie==key[i])
{
return length[i];
}
}
int * getByKey(T1 cheie)
{
int rezult[10];
for(int i=0;i<n;i++)
if(cheie==key[i])
{
cout<<endl<<"Lista de valori corespunzatoare cheii: "<<key[i];
cout<<" este: ";
for(int j=0;j<length[i];j++)
{
cout<<" "<<listvalue[i][j];
rezult[i]=listvalue[i][j];
}
}
return rezult;
}
int* getByValue(T2 val)
{
int rezult[10],k=0;
for(int i=0;i<n;i++)
{
for(int j=0;j<length[i];j++)
{
if(listvalue[i][j]==val)
{rezult[k]=key[i]; k++;}

}
}
cout<<endl<<"Cheile care contin aceasta valoare "<<val<<" sunt: ";
for(int i=0;i<k;i++)
{
cout<<endl<<" key="<<rezult[i];
}
return rezult;
}
void operator[](int x)
{
x--;
cout<<endl<<endl<<"cheia cu nr de ordine "<<x+1<<" include "<<length[x]<<" elemente :";
for(int i=0;i<length[x];i++)
cout<<" "<<listvalue[x][i];
}
friend istream &operator >>(istream &input, MultiMap&);
friend ostream &operator<<(ostream &os, MultiMap&);

};

ostream& operator<<(ostream& os, MultiMap<int,int,int> &t)


{
os<<endl<<endl<<"<< of obiectul clasei MultiMap :";
for(int i=0;i<t.n;i++)
{
os<<endl<<" key "<<t.key[i];
os<<" valori:";
for(int j=0;j<t.length[i];j++)
{
cout<<t.listvalue[i][j]<<" ";
}
}
return os;
}
istream &operator >> (istream &input, MultiMap<int,int,int> &f) {
int x,y,z;
delete f.key;
delete f.length;
delete f.listvalue;
cout<<endl<<">> a obiectul clasei MultiMap :";
cout<<endl<<endl << "Nr de key: ";
input>>x;
for(int i=0;i<x;i++)
{
cout<<endl<<"Key= "; input>>f.key[i];
cout<<endl<<"Nr de valori= "; input>>f.length[i];
for(int j=0;j<f.length[i];j++)
{
cout<<"v["<<j+1<<"]= "; input>>f.listvalue[i][j];
}
}
return (input);
}
int main(){
int *x,*y,z[10],w;
int a[3]={2,1,9};
int b[3]={3,4,2};
int c[3][10];
c[0][0]=1;c[0][1]=3;c[0][2]=6;
c[1][0]=3;c[1][1]=10;c[1][2]=0;c[1][3]=9;
c[2][0]=8;c[2][1]=8;
MultiMap<int,int,int> mapa(a,c,b,3);
mapa.ShowMap();
cout<<endl<<endl<<"Add a key=15 "<<endl;
mapa.add(15,b,3);
mapa.ShowMap();
cout<<endl<<endl<<"Delete by key=1 "<<endl;
mapa.removebykey(1);
mapa.ShowMap();
cout<<endl<<endl<<"Get length by key=2 "<<endl;
w=mapa.getLength(2);
cout<<"Length: "<<w;
cout<<endl<<endl;
x=mapa.getByKey(9);
cout<<endl<<endl;
y=mapa.getByValue(3);
cout<<mapa;
MultiMap<int,int,int> obj;
// cin>>obj;
mapa[2];
return 0;
}
Concluzii:

In urma efectuarii acestei lucrari de laborator capatat cunostinte despre modul de lucru
sabloanele in C++,in cazul functiilor parametrizate dupa parerea mea este un mecanism foarte
util si usor de interpretat,iar in cazul claselor dupa parerea mea mecanismul de scriere este foarte
complicat trebuie de prevazul ca oriude sa fie genericul prezent.