Sunteți pe pagina 1din 5

Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

ATI

RAPORT
Lucrarea de laborator nr.7
la Programarea în limbajul C++

A efectuat:
st. gr. MN151 Dimov Alexandru

A verificat:
l.s. Scrob Sergiu

Chişinău - 2016
Lucrarea de laborator nr.7

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;

Varianta 7:
Sarcine:
а) Creaţi o funcţie şablon, care schimbă după perechi elementele masivelor în felul următor: primul element va
avea valoarea sumei perechii, dar al doilea diferenţei perechii.
De exemplu: lista- 0 2 3 4 3 6, rezultatul 2 –2 7 –1 9 –3.
b) Creaţi clasa parametrizată Matrix – matrice. Clasa trebuie să conţină constructorii, destructorii şi funcţiile
getRows, getCols, operatorii [], +, -, * şi operatorii de intrare/ieşire.

Noţiuni principale din teorie:


Şabloanele reprezintă cea mai puternică construcţia a limbajului C++, dar în acelaşi timp, unul din cele
mai puţin studiate şi rar utilizat. Cauza este ascunsă în faptul că el este foarte complicat şi are o sintaxă
neobişnuită.
Aşa deci, şabloanele reprezintă prin sine 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.
Containerele sunt obiecte, care conţin alte obiecte sau date, cel mai des o cantitate nedeterminată, aşa cum sunt
masivele, stivele, liste asociative, etc. Prin algoritm abstract este necesar de înţeles studierea bună a metodelor
de prelucrare a datelor, ca sortarea, căutarea, etc., înscrise fără prezentarea tipului datelor.
Şabloanele sunt clase şi funcţii. Şabloanele au venit sa schimbe macrourile, aşa cum ultimele foarte des
duc la găsirea complicată a erorilor, deoarece compilatorul nu verifică, dar nici nu are posibilitatea să le verifice
de erori sintactice.
Programatorul, scriind şabloanele, creează aprovizionarea, care, ca urmare, se utilizează deja cu tipurile
de date specificate. Adică, la baza şabloanelor compilatorul creează funcţii normale. Dacă şabloanele sunt
utilizate cu câteva tipuri de date diferite, compilatorul creează un codul necesar pentru fiecare tip în parte. Cu
alte cuvinte, şabloanele nu micşorează compilarea modulului, mai degrabă chiar invers, dar simţitor 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.
Programul main:
A)
cin>>lista[i];
#include <stdio.h> }
#include <iostream> lista = work(lista);
cout<<"Noua lista este:"<<endl;
using namespace std; for ( int i=0;i<counter; i++){
cout<<lista[i]<<" ";
int counter; }
cout<<endl;
template <class T> system( "read -n 1 -s -p \"Press any key to continue...\"" );cout<<endl;
T* work(T* lista){ break;
T* result = new T[counter]; case 2:
for(int i=0; i<counter; i++){ lista1 = new float[counter];
if(i % 2==0) for(int i=0; i<counter; i++){
result[i] = lista[i] + lista[i+1]; cout<<"Introdu elementul: "<<i<<endl;
else cin>>lista1[i];
result[i] = lista[i-1]-lista[i]; }
} lista1 = work(lista1);
return result; cout<<"Noua lista este:"<<endl;
} for ( int i=0;i<counter; i++){
int main (){ cout<<lista1[i]<<" ";
int *lista,user_option; }
float *lista1; cout<<endl;
cout<<"Introdu numarul de elemente din lista"<<endl; system( "read -n 1 -s -p \"Press any key to continue...\"" );cout<<endl;
cin>>counter; break;
while(1){ case 3:
cout<<"1.Introdu elemente int"<<endl; delete[] lista;
cout<<"2.Introdu elemente float"<<endl; delete[] lista1;
cout<<"3.Exit"<<endl; exit(1);
cin>>user_option; }
}
switch(user_option){
case 1:
lista = new int[counter]; return 1;
for(int i=0; i<counter; i++){ }
cout<<"Introdu elementul: "<<i<<endl;
B)
for(int j=0; j<obj.cols; j++){
#include <stdio.h> out<<obj.matrix[i][j]<<" ";
#include <iostream> }
using namespace std; out<<endl;
}
template <typename T> return out;
class Matrix{ }
int rows, cols,counter; friend istream& operator>>(istream& in, Matrix<T> &obj){
T** matrix; if(!obj.matrix)
public: {
Matrix():rows(0),cols(0),matrix(NULL){}; cout << "Input row"<<endl;
Matrix(int rows, int cols, T* matrix){ in>>obj.rows;
this->rows=rows; cout << "Input col"<<endl;
this->cols=cols; in>>obj.cols;
this->matrix=matrix; obj.matrix = new T*[obj.rows];
} for(int i=0; i<obj.rows; i++){
~Matrix(){ obj.matrix[i] = new T[obj.cols];
rows=0; }
cols=0; }
matrix=NULL; for (int i=0; i<obj.rows;i++){
} for(int j=0; j<obj.cols; j++){
void setRows(int rows){this->rows=rows;} cout<<"matr ["<<i<<"]["<<j<<"]";
void setCols(int cols){this->cols=cols;} in>>obj.matrix[i][j];
void setMatrix(); }
void showMatrix(int rows, int cols){ }
for(int i=0; i<rows; i++){ return in;
for(int j=0; j<cols; j++){ }
cout<<matrix[i][j]<<" "; //Matrix<T>& operator= (const Matrix<T>& obj);
} Matrix<T> operator+ (Matrix<T>&);
cout<<endl; Matrix<T> operator- (Matrix<T>&);
} Matrix<T> operator* (Matrix<T>&);
} };
int getRows();
int getCols(); template <typename T>
T** getMatrix(); int Matrix<T>::getRows(){
T operator[](int i); return rows;
friend ostream& operator<<(ostream& out, Matrix<T> &obj){ }
for (int i=0; i<obj.rows;i++){
template <typename T> for(int i=0;i<rows;i++){
int Matrix<T>::getCols(){ for(int j=0;j<obj.cols;j++){
return cols; sum=0;
} for(int k=0;k<cols;k++){
sum = sum + (matrix[i][k]*obj.matrix[k][j]);
template <typename T> }
T** Matrix<T>::getMatrix(){ result.matrix[i][j] = sum;
return matrix; }
} }
}
template <typename T> return result;
T Matrix<T>::operator[](int i){ }
return (matrix[i]);
} int main(){
Matrix<float> a;
template <typename T> Matrix<float> b;
void Matrix<T>::setMatrix(){ Matrix<float> c;
cout<<"Introdu numarul de rows"<<endl; int user_option;
cin>>rows; while(1){
cout<<"Introdu numarul de cols"<<endl; system("clear");
cin>>cols; cout<<"1.Introdu datele matricei a :"<<endl;
matrix = new T*[rows]; cout<<"2.Introdu datele matricei b :"<<endl;
for(int i=0; i<rows; i++){ cout<<"3.Suma matricelor a si b : "<<endl;
matrix[i] = new T[cols]; cout<<"4.Scaderea matricelor a si b : "<<endl;
} cout<<"5.Produsul matricelor a si b: "<<endl;
cout<<"Introdu elementele matricei"<<endl; cout<<"6.Afiseaza matricea a:"<<endl;
for(int i=0; i<rows; i++){ cout<<"7.Afiseaza matricea b:"<<endl;
for(int j=0; j<cols; j++){ cout<<"8.Afiseaza amtricea c:"<<endl;
cout<<"matr ["<<i<<"]["<<j<<"]="; cout<<"0.Exit"<<endl;
cin>>matrix[i][j]; cin>>user_option;
} switch(user_option){
} case 1:
} // a.setMatrix();
cin>>a;
template <typename T> break;
Matrix<T> Matrix<T>::operator+(Matrix<T>& obj){ case 2:
Matrix<T> result (*this); //b.setMatrix();
if(rows!=obj.rows && cols!=obj.cols) cin>>b;
cout<<"Sizes differ"<<endl; break;
else{ case 3:
result.matrix = new T*[rows]; c = (a+b);
for (int i=0;i<rows;i++) c.showMatrix(c.getRows(),c.getCols());
result.matrix[i] = new T[cols]; system( "read -n 1 -s -p \"Press any key to continue...\"" );
for(int i=0; i<rows; i++){ break;
for(int j=0; j<cols; j++){ case 4:
result.matrix[i][j]=matrix[i][j]+obj.matrix[i][j]; c = a-b;
} c.showMatrix(c.getRows(),c.getCols());
} system( "read -n 1 -s -p \"Press any key to continue...\"" );
} break;
return result; case 5:
} c=a*b;
c.showMatrix(a.getRows(),b.getCols());
template <typename T> system( "read -n 1 -s -p \"Press any key to continue...\"" );
Matrix<T> Matrix<T>::operator-(Matrix<T>& obj){ break;
Matrix<T> result (*this); case 6:
if(rows!=obj.rows && cols!=obj.cols) cout<<a;
cout<<"Sizes differ"<<endl; system( "read -n 1 -s -p \"Press any key to continue...\"" );
else{ break;
result.matrix = new T*[rows]; case 7:
for (int i=0;i<rows;i++) cout<<b;
result.matrix[i] = new T[cols]; system( "read -n 1 -s -p \"Press any key to continue...\"" );
for(int i=0; i<rows; i++){ break;
for(int j=0; j<cols; j++){ case 8:
result.matrix[i][j]=matrix[i][j]-obj.matrix[i][j]; c.showMatrix(a.getRows(),b.getCols());
} system( "read -n 1 -s -p \"Press any key to continue...\"" );
} break;
}
return result; case 0:
} exit(1);
break;
template <typename T> }
Matrix<T> Matrix<T>::operator*(Matrix<T>& obj){ }
Matrix<T> result (*this); return 1;
T sum; }
if(rows!=obj.cols && cols!=obj.rows)
cout<<"Rows!=cols && cols!=rows"<<endl;
else{
result.matrix = new T*[rows];
for (int i=0;i<rows;i++)
result.matrix[i] = new T[cols];
Rezultatele programelor:
A)

Concluzie

Realizând această lucrare de laborator, am folosit sabloanele. Am folosit in practica utilizarea acestui
proces, si am studiat regulile de folosire a lui. Acest proces ne este foarte util, pentru micsorarea codului, si
utilizarea acestui mecanism, pentru a folosi diferite tipuri de date in aceeasi functie sau clasa. În viitor voi putea
aplica la necesitate acest mecanism.
Întrebări de control:

1. Ce reprezintă prin sine şabloanele?


2. Care sunt avantajele utilizării şabloanelor?
3. Pentru ce se utilizează specializarea?
4. Ce poate fi un şablon?
5. Care sunt problemele utilizării şabloanelor?
6. Utilizarea şabloanelor duce la economia memoriei?
7. Dar a timpului de executare a compilării codului?
8. Poate o clasă şablon să moştenească una obişnuită şi invers?

Raspunsuri:
1. Este o constructie a limbajului C++ ce permit utilizarea unei functii, clase pentru diferite tipuri.
2. Ne micsoreaza codul si diverse erori.
3. Se utilizeaza pentru a utiliza functia noastra pentru un anumit tip de date.
4. Acestea pot fi mostenite.
5. Ele lucreaza excelent pentru tipurile incorporate ca int, float si altele, dar pentru siruri nu lucreaza.
6. Da
7. O mica parte.
8. Şabloanele clasei pot fi moştenite, aşa ca şi cele obişnuite, cu aceasta, şi acel de bază, aşa şi a cel derivat
pot fi clase obişnuite.