Ministerul Educaţiei ,Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare,Informatică și Microelectronică
Departamentul Informatică și Ingineria Sistemelor

RAPORT
Lucrarea de laborator Nr.7
Varianta:8
Tema:” Şabloane”

Diciplina:,,Programarea Orientata pe Obiecte”

A efectuat: st. gr.MN-181 Moraru Cristian

A verificat: dr., conf.univ. Osovschi Mariana

2019
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;

Sarcina Lucrarii:
а) Creaţi o funcţie şablon, care modifică ordinea elementelor invers.
De exemplu: 1 2 3 4 5 6 - 6 5 4 3 2 1. Funcţia trebuie să lucreze cu masive de lungimi diferite.
b) Creaţi clasa parametrizată Tree – arbore binar. Clasa trebuie să conţină constructorii,
destructorii şi funcţiile add, in, funcţia de eludare a arborelului şi operatorii de intrare/ieşire.

Codul Programului:
#include <iostream>
#include <vector>

template <typename T, size_t N>

void inversareMatrice(T (&arr)[N], int size) {
int end = size - 1;
T temp = 0;
for (int i = 0; i < size / 2; ++i) {
temp = arr[i];
std::cout << "temp= " << temp << std::endl;
arr[i] = arr[end];
arr[end] = temp;
end -= 1;
}
}
int main() {
int array[] = {1,2,3,4,5,6,7,8,9,10};

inversareMatrice<int>(array, 10);
 for (int elem: array) {
std::cout<< elem << " ";
}
return 0;
}
Rezultatul Programului:

Codul Programului:
#include <iostream>

template <class T>

class Tree

struct node{

T value;

struct node* right;

struct node* left;

};

public:

Tree();

~Tree();

void add(T val);

 void printPreOrder();

void printInOrder();

void printPostOrder();

template <class>

friend std::ostream&operator << (std::ostream &os, Tree<T> &o);

template <class>

friend std::istream&operator >> (std::istream &is, Tree<T> &i);

private:

struct node* root;

int treeSize;

void add(struct node** node, T val);

void printPreOrder(struct node* node);

void printInOrder(struct node* node);

void printPostOrder(struct node* node);

void deleteTree(struct node* node);

};

template <class T>

Tree<T>::Tree(){

this->root = 0;

this->treeSize = 0;

template <class T>

Tree<T>::~Tree(){

deleteTree(this->root);

template <class T>

void Tree<T>::add(T val){

add(&(this->root), val);
}

template <class T>

void Tree<T>::add(struct node** node, T val){

if(*node == 0) {

auto* tmp = new struct node;

tmp->value = val;

tmp->left=0;

tmp->right = 0;

*node = tmp;

this->treeSize++;

}else{

if(val > (*node)->value){

add(&(*node)->right, val);

}else{

add(&(*node)->left, val);

template <class T>

void Tree<T>::printInOrder(){

printInOrder(this->root);

std::cout << std::endl;

template <class T>

void Tree<T>::printInOrder(struct node* node){

if(node != 0){

printInOrder(node->left);
 std::cout << node->value << ", ";

printInOrder(node->right);

template <class T>

void Tree<T>::printPreOrder(){

printPreOrder(this->root);

std::cout << std::endl;

template <class T>

void Tree<T>::printPreOrder(struct node* node){

if(node != 0) {

std::cout << node->value << ", ";

printInOrder(node->left);

printInOrder(node->right);

template <class T>

void Tree<T>::printPostOrder(){

printPostOrder(this->root);

std::cout << std::endl;

template <class T>

void Tree<T>::printPostOrder(struct node* node){

if(node != 0){

printInOrder(node->left);

printInOrder(node->right);

std::cout << node->value << ", ";

 }

template <class T>

void Tree<T>::deleteTree(struct node* node){

if(node != 0){

deleteTree(node->left);

deleteTree(node->right);

delete node;

template <class T>

void operator<<(std::ostream &os, Tree<T> &o) {

return o.printInOrder();

template<class T>

std::istream &operator>>(std::istream &is, Tree<T> &i) {

T val;

std::cout << "val: ";

is >> val;

i.add(val);

return is;

int main(){

Tree<int> tree;

tree.add(5);
 tree.add(4);

tree.add(7);

tree.add(10);

tree.add(1);

tree.add(2);

std::cin >> tree;

std::cout << tree;

Tree<char> obj;

std::cin >> obj;

std::cout << obj;

Rezultatul Programului:

Concluzie:

 In rezultatul elaborarii lucrarii date s-a pus baza aplicarii in practica a cunostintelor
teoretice referitoare OOP, la sabloane in C++.
 Astfel se poate judeca despre posibilitatile largi acordate de limbajul C++ referitor la
manipularea claselor.