Laborator 3

Descărcați ca docx, pdf sau txt
Descărcați ca docx, pdf sau txt
Sunteți pe pagina 1din 17

Lucrarea de laborator nr.

3
Tema: Supraincarcarea funcțiilor și a operatorilor, funcții prietene.

Scopul lucrării: familiarizarea studenţilor cu noţiunile: metode supraăncărcate,


operatori supraîncărcaţi funcții prietene.

Supraîncărcarea funcţiilor

Limbajul C++ permite utilizarea mai multor funcţii care au acelaşi nume,
caracteristică numită supraîncărcarea funcţiilor.
Identificarea lor se face prin numărul de parametri şi tipul lor.

Exemplu:

int suma (int a, int b)


{
return (a , b);
}
float suma(float a,float b)
{
return (a , b);
}

Dacă se apelează suma (3,5), se va apela funcţia corespunzătoare tipului int, iar
dacă se apelează suma (2.3, 9),
se va apela funcţia care are parametrii de tipul float.
La apelul funcţiei suma (2.3, 9), tipul valorii 9 va fi convertit automat de C++ în float
(nu e nevoie de typecasting).

Funcţii cu valori implicite

În funcţie se pot declara valori implicite pentru unul sau mai mulţi parametri.
Atunci cînd este apelată funcţia, se poate omite specificarea valorii pentru acei parametri
formali care au declarate valori implicite. Valorile implicite se specifică o singură
dată în definiţie (de obicei în prototip). Argumentele cu valori implicite trebuie să
fie amplasate la sfîrşitul listei.

Exemplu:
void adunare (int a=5 double b=10)
{...;}
...
Adunare(); //adunare(4,10);
Adunare(1); //adunare(1,10);
Adunare(3,7); //adunare(3,7);

Supraincarcarea operatorilor

Atunci când creaţi o clasă, C++ vă permite să supraîncărcaţi operatorii pentru a


lucra cu propriile clase.
Când supraîncărcaţi un operator, trebuie să continuaţi să utilizaţi operatorul în
formatul său standard. De exemplu, dacă supraîncărcaţi operatorul plus (+), acesta
trebuie să utilizeze operatorul sub forma operand+operand . Operatorul
supraîncărcat creat se aplică numai instanţelor clasei specificate

Atunci când creaţi funcţii operator membre pentru a supraîncărca funcţionarea


unui operator, declaraţiile membrilor operatori vor avea forma generală prezentată
mai jos:
tip-return nume-clasa::operator #(lista-argumente)
{
// Operatii
}

unde # este simbolul oricărui operator C++, exceptînd:


. – operator de membru al clase
* – adresare la componenta prin pointer,
:: – operatorul de rezoluţie,
() ?: – operatorul condiţional,
operatorul sizeof, etc..
Această definire se face în cadrul clasei, întocmai ca o funcţie membru.

Există două variante de definire a operatorilor:


– ca funcţie membru a clasei;
– ca funcţie prietenă a clasei.

O funcţie operator are aceleaşi componente pe care le are orice funcţie, include un
nume, un tip returnat, argumente, corp şi, eventual, apartenenţa la o clasă.
Există trei elemente care trebuie stabilite la declararea operatorului, şi anume:
– este operator unar sau binar,
– este postfixat sau prefixat ca poziţie
– este funcţie membru sau nu – domeniu de acţiune.
Funcţiile operator membri vor avea cu un argument mai puţin decît cele non-
membri.
Puteţi să supraîncărcaţi numai operatorii existenţi. C++ nu vă permite definirea
unor operatori proprii.
Definirea operatorilor ca funcţii membri a unei clase prezintă o restricţie
majoră: primul operand este obligatoriu să fie de tipul clasa respectiv.
În limbajul C++ supradefinirea operatorilor este supusă unui set de restricţii:
– nu este permis introducerea de noi simboluri de operatori;
– patru operatori nu pot fi redefiniţi (vezi mai sus);
– caracteristicile operatorilor nu pot fi schimbate:
1. pluralitatea (nu se poate supradefini un operator unar ca
operator binar sau invers),
2. precedenţa şi asociativitatea,
3. prioritatea lor;
– funcţia operator trebuie sa aibă cel puţin un parametru de tipul clasa căruia îi
este asociat operatorul supradefinit.
Programatorul are libertatea de a alege natura operaţiei realizate de un operator,
însă este recomandat ca noua operaţie să fie apropiată de semnificaţia iniţială.

Pot fi redefiniti operatorii din urmatoarea tabela:


Tabelul 1.
Tipul operatorului Simbolul operatorului Observaţii
Se definesc ca funcţii
Binar (); [] ;->;
membri
Unar +; - ;~; *; & (tip)
Nu se poate dis-tinge
Unar ++; - -
între pre- şi postfixare
Poate fi supra-definit şi
Unar new; delete
pentru o clasă
->; *; /; %; +; -; &;|;
Binar
&&; ||
<<; >> ;< ;<=; > ;>=; ==
Binar
;!=
= ;+=; -= ;*=; /=;%= Se definesc ca funcţii
Binar
;&=; ^=;|= ;<<=; >>= membri
Binar ,
Pentru exemplificare, vom extinde clasa Point cu utilizarea unor operatori.
class Point
{// ...
Point& operator += (Point p);
Point& operator -= (Point p);
Point operator + (Point p);
Point operator - (Point p);
Point& operator = (Point p);
int operator == (Point p);
int operator != (Point p);
int operator < (Point p);
int operator > (Point p);
int operator <= (Point p);
int operator >= (Point p);
};
Point& Point::operator += (Point p)
{x += p.x; y += p.y; return *this;}
Point& Point::operator -= (Point p)
{x -= p.x; y -= p.y; return *this;}
Point Point::operator + (Point p)
{return Point(x + p.x, y + p.y);}
Point Point::operator - (Point p)
{return Point(x -p.x, y -p.y);}
int Point::operator == (Point p)
{return x == p.x && y == p.y;}
int Point::operator != (Point p)
{return !(*this == p);}
int Point::operator < (Point p)
{return x < p.x && y < p.y;}
int Point::operator > (Point p)
{return x > p.x && y > p.y;}
int Point::operator <= (Point p)
{return x <= p.x && y <= p.y;}
int Point::operator >= (Point p)
{return x >=p.x && y >= p.y;}
Am utilizat mai sus varianta cu funcţii membri. Vom descrie implementarea
operatorului + folosind cea de-a doua variantă.
class Point {
// ...
friend Point operator + (Point p1, Point p2);
};
Point operator + (Point p1, Point p2)
{return Point(p1.x + p2.x, p1.y + p2.y);}
1. Redefinirea operatorului =
Operatorul = este deja predefinit în C++, pentru operanzi de tip clasă. Dacă nu
este supradefinită, atribuirea se face membru cu membru în mod similar cu
iniţializarea obiectului efectuată de către compilator. În caz de o atribuire specifică
a clasei, operatorul = poate fi supradefinit:

Point& Point::operator = (Point p)


{x = p.x; y =p.y; return *this;}

2. Redefinirea operatorului +
Următorul program creează o clasă Sir şi supraîncarcă operatorul plus (+) astfel
că acesta concatenează şirurile:

#include <iostream.h>
#include <iomanip.h>
#include <string.h>
class Sir // Definirea clasei
{ public:
Sir *operator +(char *sir_adaug); // operator
Sir (char *in_sir) // constructor
{ strcpy(buffer, in_sir);
lungime = strlen(buffer); }
Sir(void) {lungime =0;};
void arata_sir() { cout « buffer; };
private:
char buffer[256];
int lungime;
}; // Aici se termina clasa

Sir Sir::operator+(char *sir_adaug)


{
Sir temp;
int lungimeTemp;
lungimeTemp = strlen(buffer) + strlen(sir_adaug) + 1;
if(lungimeTemp>256)
{
cout « "Sir prea lung!" « endl;
strcpy(temp.buffer, buffer);
return temp;
}
lungime = lungimeTemp;
strcpy(temp.buffer, buffer);
strcat(temp.buffer, sir_adaug);
return temp;
}

void main(void)
{
Sir titlu("Autor ");
titlu = titlu + "Titlul carttii\n";
titlu.aratasir();
}

Atunci când rulaţi programul , el va începe prin atribuirea membrului buffer şirului
„Autor". Programul va utiliza apoi operatorul plus supraîncărcat pentru a
concatena caracterele „Titlul cartii". Observaţi că operatorul supraîncărcat este o
funcţie simplă care primeşte un parametru. Funcţia primeşte numai un singur
parametru. Parametrul este al doilea operand. Operaţia însăşi implică operandul
instanţei.
Operatorul supraîncărcat plus utilizează funcţiile strcpy şi strcat pentru a copia
şirul de caractere dintre ghilimele în obiectul titlu. Observaţi că acest cod din
cadrul funcţiei operator plus supraîncărcate se referă la datele membre ale
obiectului titlu în mod implicit, cu comenzi cum sunt următoarele, care plasează
valoarea curentă a tidului în obiectul temp:
strcpy (temp.buffer, buffer) ;
Programul ar putea la fel de uşor să facă referire la obiect în mod explicit, utilizând
pointerul this, ca mai jos:
strcpy(temp.buffer, this.buffer);

3. Redefinirea operatorului de indexare[].


C++ consideră operatorul de undexare ca pe un operator binar pentru scopurile
supraîncărcării. Prin urmare, forma generală a supraîncărcării unei funcţii membre
operator este:
tip numeClasa::operator[ ](int i)
{
// . . .
}

Din punct de vedere tehnic, parametrul i nu trebuie neapărat să fie de tipul int, dar
deoarece veţi defini de obicei matricele cu un parametru întreg, trebuie să evitaţi
utilizarea unui parametru de tipul float sau de alt tip. Atunci când apelaţi funcţia
operator supraîncărcată, C++ va atribui pointerul this la obiect şi va folosi
parametrul pentru a controla dimensiunea. Pentru a înţelege mai bine prelucrările
pe care le efectuează funcţia supraîncărcată [ ] pentru matrice, analizaţi următorul
program:
#include <iostream.h>
class TipOarecare
{
int a[3];
public:
TipOarecare(int i, int j, int k) // constructor
{
a[0] = i;
a[1] = j;
a[2] = k;
}
int operator[] (int i) {return a[i];}
};
void main(void)
{
TipOarecare ob(l, 2, 3);
cout << ob[l] ;
}
Supraîncărcarea operatorului [ ] pentru matrice vă oferă posibilitatea de a controla
mai bine crearea matricelor cu clase. Pe lângă faptul că vă permite să atribuiţi
valori distincte pentru fiecare membru, puteţi utiliza funcţiile supraîncărcate pentru
a crea un program care sî efectueze o indexare sigură a unei matrice. Indexarea
sigură a unei matrice contribuie 1a prevenirea supradepăşirii sau subdepăşirii
limitelor unei matrice în decursul execuţiei unu program. Următorul program
extinde programul precedent pentru a realiza şi indexarea sigură a matricei:
#include <iostream.h>
#include <stdlib.h>
class TipOarecare
{
int a[3];
public:
TipOarecare(int i, int j, int k)
{
a[0]=i;
a[1]=j;
a[2]=k;
}
int &operator[](int i);
};
int &tipoarecare::operator[] (int i)
{ if (i<0 || i>2 )
{
cout <<”eroare la margini. \n”;
exit (1);
}
return a[i];
}
};
void main (void)
{ TipOarecare ob(l, 2, 3) ;
cout <<ob[l]; cout <<endl;
ob[l] = 25;
cout <<ob[1]; cout <<endl;
ob[3] =44;
}
Atunci când încercaţi să accesaţi un obiect de dincolo de marginile matricei, se va
produce o eroare. În cazul programului, încercarea de a accesa elementul de la
indicele 3 se face dincolo de margini şi prin urmare programul va returna o eroare.
Atunci când executaţi programul el va genera următorul rezultat:
2
25
Eroare la margini
C:\>

5. Exemplu numerelor complexe

Să se scrie un program care să definească un nou tip de variabile - tipul complex şi


să construiască funcţii adecvate pentru operaţiile de bază cu acest tip de date
(adunare, scădere, înmulţire, calculul modulului numărului complex).
#include<iostream>
#include<math.h>
using namespace std;
class complex
{
public:
float x, y;
float modul(); //il folosim pentru a returna modulul
complex(); // vom initializa pe x si y cu 0
complex(float a, float b); //il folosim pentru a copia a in x si b in y
complex operator+(complex k);
complex operator-(complex k);
complex operator*(complex k);
complex operator/(complex k);
};
complex::complex()
{
x=0;
y=0;
}
complex::complex(float a, float b) //constructor de copiere
{
x=a;
y=b;
}
//pentru adunarea a doua numere complexe folosim formula
// ... =x1+x2 +i(y1+y2)
complex complex::operator+(complex k)
{
complex h; //ne folosim de un obiect "auxiliar"
h.x=x+k.y;
h.y=y+k.y;
return h;
}
//pentru scaderea a doua numere complexe folosim formula
// ...=x1-x2+i(y1-y2)
complex complex::operator-(complex k)
{
complex h;
h.x=x-k.x;
h.y=x-k.y;
return h;
}
//pentru inmultirea a doua numere complexe folosim formula
// ...=x1x2-y1y2+i(x1y2+x2y1)
complex complex::operator*(complex k)
{
complex h;
h.x=x*k.x;
h.y=y*k.y;
return h;
}
//pentru impartire folosim formula:
// ...=(x1x2+y1y1+i(x2y1-x1y2))/x2^2+x1^2
complex complex::operator/(complex k)
{
complex h;
float aux=k.x*k.x+k.y*k.y; //retine x^2+y^2
if(aux)
{
h.x=(x*k.x+y*k.y)/aux;
h.y=(k.x*y-x*k.y)/aux;
}
else
cout<<"impartire la 0!!";
return h;
}
float complex::modul()
{
return sqrt(x*x+y*y);
}
int main()
{
complex z1, z2, z3, z4(1, 0); //pentru z1, z2, z3 se apeleaza constructorul
implicit care va initializa pe x si y pentru fiecare obiect cu 0.
//in cazul lui z4 se apeleaza cel cu 2 parametri
int n,i;
cout<<"n=";
cin>>n;
cout<<"z1="<<endl;
cin>>z1.x>>z1.y; //se citesc noi valori pentru x si y, atat in cazul lui z1,
cout<<"z2="<<endl;
cin>>z2.x>>z2.y; //cat si in cazul lui z2
z3=z1/z2; //z3 are x=0 si y=0, acestia se vor primi noi valori in urma
operatiei de "/"
for(i=1; i<=n; i++)
z4=z4*z3;
cout<<z4.x<<" "<<z4.y;
system("PAUSE");
return 0;
}
//obs: functiile obtinute prin supraincarcarea operatorilor au aceeasi prioritate si
asociativitate ca operatorii respectivi
//functiile obtinute prin supaincarcarea operatorilor au aceeasi n-aritate ca si
operatorii respecttivi, astfel:
//daca operatorul este unar si functia este unara, deci nu are parametri
//daca operatorul este binar si functia este binara, aceasta inseamna ca are un singur
parametru.

Funcții prietene

Pentru a admite accesul la elementele protejate si pentru anumite functii care nu


sunt membru au fost create functii, care au fost numite functii prieten (friend)
pentru clasa respectiva. Ele trebuie precizate la definitia clasei. In acest scop,
prototipurile lor sunt prezente in definitia clasei si sunt precedate de cuvantul cheie
friend.
Exemplu:
class complex
{
double real;
double imag;
public:
complex(double x=0,double y=0)
{
real=x;
imag=y;
}
friend double modul(complex *z);
….
};

Spre deosebire de functiile membru, in cazul functiilor prieten nu mai


este definit pointerul implicit this. Acest lucru conduce la faptul ca o
functie prieten are un parametru in plus fata de o functie membru care
are acelasi efect.
O functie prieten poate fi o functie obisnuita sau o functie membru a
unei alte clase.
Exemplu:
Sa se defineasca tipul de date complex care sa aiba functii membru
pentru:
- modul, argument
- accesul la partea reala si imaginara a obiectelor de tip complex
- afisarea obiectelor complexe
- constructori pentru initializare si copiere Sa se scrie un program care
realizeaza urmatoarele:
- citeste perechi de n numere care reprezinta fiecare, partea reala si
respectiv imaginara a unui numar complex
- afiseaza: numarul complex citit suma numerelor complexe citite

#include<iostream.h>
#include<math.h>
#define PI 3.14159265358979
class complex
{
// date membru protejate(private)
double real;
double imag;
// functii membru neprotejate
public:
// constructor folosit la initializare
complex(double x=0,double y=0);
// constructor de copiere
complex(const complex &);
// modulul numarului complex
double modul();
// argumentul numarului complex
double arg();
// returneaza partea reala
double retreal();
// returneaza partea imaginara
double retimag();
// afiseaza numarul complex
void afiscomplex();
};
complex::complex(double x, double y)
{
real=x;
imag=y;
}
complex::complex(const complex &z)
{
real=z.real;
imag=z.imag;
}
double complex::modul()
{
return sqrt(real*real+imag*imag);
}
double complex::arg()
{
double a;
if( (real==0) && (imag==0) )
return 0.0;
if(imag==0)
if(real>0)
return 0.0;
else
return PI;
if(real==0)
if(imag>0)
return PI/2;
else
return (3*PI)/2;
a=atan(imag/real);
if(real<0)
return a+PI;
else
if(imag<0)
return 2*PI+a;
return a;
// real>0 si imag>0
}
double complex::retreal()
{
return real;
}
double complex::retimag()
{
return imag; }
void complex::afiscomplex()
{ cout<<real<<" + i * "<<imag; }
int main(void)
{ double x,y,sumax=0,sumay=0,i=0,n;
cout<<"Dati numarul de nr. complexe n = "; cin>>n;
while(i<n)
{
cout<<"Partea reala = ";cin>>x;
cout<<"Partea imaginara = ";
cin>>y;
sumax+=x;sumay+=y;
// se construieste nr. complex avand partile citite mai sus; se
apeleaza constructorul care realizeaza initializarea
// obiectului z=x+i*y
complex z(x,y);
// afisez numarul z
cout<<endl; z.afiscomplex(); i++;
}
complex sz=complex(sumax,sumay);
cout<<endl<<"Suma nr. complexe citite este ";
sz.afiscomplex();
return 0;
}
Sarcina
Varianta 1
Să se creeze o clasă de numere întregi. Să se definească operatorii "++" , ca metode ale clasei,
iar "-" ca funcţie prietenă. Operatorii trebuie să permită efectuarea operaţiilor cu variabilele
clasei date. Realizați supaăncărcarea funcției realizînd operații saupra datelor din clasă. Clasa
trebuie să fie absolut funcţională, adică să conţină toţi constructorii necesari şi destructorul.
Varianta 2

Să se creeze clasa 2-D de coordonate în plan. Să se definească operatorii "+" ca funcţie prietenă,
iar operatorul de atribuire – ca metodu ale clasei. De prevăzut posibilitatea efectuării operaţiilor
între coordonate. Realizați supaăncărcarea funcției realizînd operații saupra datelor din clasă.
Clasa trebuie să fie absolut funcţională, adică să conţină toţi constructorii necesari şi destructorul.

Varianta 3
Să se creeze clasa Queue –coadă, utilizînd memoria dinamică. Să se definească operatorul "=" –
de atribuire ca metode ale clasei. Să se definească operatorul de comparare "==" ca funcţie
prietenă. Să se realizeze supaăncărcarea funcției pentru inserarea/eliminarea elementelor în/din
coadă. Clasa trebuie să fie absolut funcţională, adică să conţină toţi constructorii necesari şi
destructorul.
Varianta 4
Să se creeze clasa Date – data, care conţine cîmpurile: ziua, luna, anul. Să se definească
operatorul "-" ca metodă ale clasei, iar operatorul "++" ca funcţie prietenă. Operatorii trebuie
să permită realizarea operaţiilor cu variabilele clasei. Realizați supaăncărcarea funcției pentru
prelucrarea corectă a anilor bisecţi. Clasa trebuie să fie absolut funcţională, adică să conţină toţi
constructorii necesari şi destructorul.
Varianta 5
а) Să se creeze clasa numerelor reale. Să se definească operatorul "+" ca metode ale clasei, iar
operatorul "- -" – ca funcţii prietene. Operatorii trebuie să permită realizarea operaţiilor cu
variabilele clasei date. Realizați supaăncărcarea funcției realizînd operații saupra datelor din
clasă. Clasa trebuie să fie absolut funcţională, adică să conţină toţi constructorii necesari şi
destructorul.

Varianta 6
Să se creeze clasa numerelor mari întregi. Să se definească operatorul "*" ca metode ale clasei,
iar "/" - ca funcţie prietenă. Să se supraîncarce funcția pentru incrementare şi de decrementare.
Operatorii trebuie să permită realizarea operaţiilor cu variabilele clasei date. Realizați
supaăncărcarea funcției realizînd operații saupra datelor din clasă. Clasa trebuie să fie absolut
funcţională, adică să conţină toţi constructorii necesari şi destructorul.
Varianta 7
Să se creeze clasa Bool – variabile logice. Să se definească operatorul – SAU logic ca metodă ale
clasei, iar operatorul – ŞI logic ca funcţie prietenă. Operatorii trebuie să permită realizarea
operaţiilor cu variabilele clasei date. (Dacă numărul întreg este diferit de zero, se consideră că
variabila este adevăr, altfel – fals.) Realizați supaăncărcarea funcției realizînd operații saupra
datelor din clasă. Clasa trebuie să fie absolut funcţională, adică să conţină toţi constructorii
necesari şi destructorul.
Varianta 8
Să se creeze clasa Stack – stivă, utilizînd memoria dinamică. Să se definească operatorul ca
metode ale clasei: "+" – de adunare a două stive, Să se definească operatorul de comparare: "!="
comparare a două stive, ca funcţie prietenă. Clasa trebuie să fie absolut funcţională, adică să
conţină toţi constructorii necesari şi destructorul. Realizați supaăncărcarea funcției realizînd
operații saupra datelor din clasă.
Varianta 9
Să se creeze clasa Queue – coadă, utilizînd memoria dinamică. Să se definească operatorul "+" –
de adunare a două cozi, ca metode ale clasei. Să se definească operatorul de comparare "==", ca
funcţie prietenă. Realizați supaăncărcarea funcției realizînd operații saupra datelor din clasă.
Clasa trebuie să fie absolut funcţională, adică să conţină toţi constructorii necesari şi destructorul.

Varianta 10
Să se creeze o clasă Set – mulţimea numerelor întregi, utilizînd memoria dinamică. Să se
definească operatoriul de lucru cu mulţimile – intersecţia, ca metodă ale clasei, iar "+=" –
înserarea unui nou element în mulţime, ca funcţii prietene. Realizați supaăncărcarea funcției
realizînd operații saupra datelor din clasă. Clasa trebuie să fie absolut funcţională, adică să
conţină toţi constructorii necesari şi destructorul.
Varianta 11
Să se creeze clasa String – şir, utilizînd memoria dinamică. Să se definească operatorul "+=" –
atribuirea ca funcţii prietene. Să se definească operatorul de comparare: "!=", ca metodă ale
clasei. Realizați supaăncărcarea funcției realizînd operații saupra datelor din clasă. Clasa trebuie
să fie absolut funcţională, adică să conţină toţi constructorii necesari şi destructorul.
Varianta 12
b) Să se creeze clasa List – coadă, utilizînd memoria dinamică. Să se definească operatorul "+" –
de adunare a listelor, ca funcţie prietenă. Să se definească operatorul de comparare "==", ca
metodă ale clasei. Realizați supaăncărcarea funcției realizînd operații saupra datelor din clasă.
Clasa trebuie să fie absolut funcţională, adică să conţină toţi constructorii necesari şi destructorul.

S-ar putea să vă placă și

  • Lab 3 MMC
    Lab 3 MMC
    Document4 pagini
    Lab 3 MMC
    Adrian Bodorin
    Încă nu există evaluări
  • Programarea Avansata
    Programarea Avansata
    Document8 pagini
    Programarea Avansata
    iry_piry
    Încă nu există evaluări
  • Lab NR 4 MMC2 Duca Dumitru TI 194
    Lab NR 4 MMC2 Duca Dumitru TI 194
    Document11 pagini
    Lab NR 4 MMC2 Duca Dumitru TI 194
    Santa Claus
    Încă nu există evaluări
  • LAB5
    LAB5
    Document15 pagini
    LAB5
    DorelDjj
    Încă nu există evaluări
  • Laborator Nr.3 C++
    Laborator Nr.3 C++
    Document17 pagini
    Laborator Nr.3 C++
    Cristik95
    100% (1)
  • Lab 7
    Lab 7
    Document8 pagini
    Lab 7
    Ion Popescu
    Încă nu există evaluări
  • Lab 6 Cazacu POO
    Lab 6 Cazacu POO
    Document5 pagini
    Lab 6 Cazacu POO
    Iura Cazacu
    Încă nu există evaluări
  • MMC2 Modulul2
    MMC2 Modulul2
    Document16 pagini
    MMC2 Modulul2
    ViorelRotari
    Încă nu există evaluări
  • Lab 7 Cazacu POO
    Lab 7 Cazacu POO
    Document8 pagini
    Lab 7 Cazacu POO
    Iura Cazacu
    Încă nu există evaluări
  • TAP Lab4
    TAP Lab4
    Document10 pagini
    TAP Lab4
    Cristian Batir
    Încă nu există evaluări
  • Lab 4 MN
    Lab 4 MN
    Document3 pagini
    Lab 4 MN
    nn nnn
    Încă nu există evaluări
  • Lab 4 Apa
    Lab 4 Apa
    Document21 pagini
    Lab 4 Apa
    crismaruion
    Încă nu există evaluări
  • TW Lab4
    TW Lab4
    Document8 pagini
    TW Lab4
    Dan
    Încă nu există evaluări
  • Laborator-2mmc Balan Ion
    Laborator-2mmc Balan Ion
    Document12 pagini
    Laborator-2mmc Balan Ion
    Ion Bn
    Încă nu există evaluări
  • Grafica Laborator Nr.3
    Grafica Laborator Nr.3
    Document5 pagini
    Grafica Laborator Nr.3
    Cebotari Ion
    100% (2)
  • MMC Lab2
    MMC Lab2
    Document6 pagini
    MMC Lab2
    Mihail Boran
    Încă nu există evaluări
  • Lab 4 Cazacu POO
    Lab 4 Cazacu POO
    Document8 pagini
    Lab 4 Cazacu POO
    Iura Cazacu
    Încă nu există evaluări
  • LFA Lab - 1
    LFA Lab - 1
    Document10 pagini
    LFA Lab - 1
    RoscaFlorin
    100% (1)
  • Lab 3 Somipp
    Lab 3 Somipp
    Document14 pagini
    Lab 3 Somipp
    Augusta Bucataru
    Încă nu există evaluări
  • Metode Și Modele de Calcul 2
    Metode Și Modele de Calcul 2
    Document6 pagini
    Metode Și Modele de Calcul 2
    I LOVE ME
    Încă nu există evaluări
  • Lucrarea de Laborator NR 4 POO
    Lucrarea de Laborator NR 4 POO
    Document10 pagini
    Lucrarea de Laborator NR 4 POO
    Alexandru Burdeniuc
    Încă nu există evaluări
  • Laborator 1 Cucu Eugeniu
    Laborator 1 Cucu Eugeniu
    Document5 pagini
    Laborator 1 Cucu Eugeniu
    Cucu Eugen
    Încă nu există evaluări
  • MMC Lab3 Rap
    MMC Lab3 Rap
    Document4 pagini
    MMC Lab3 Rap
    I LOVE ME
    Încă nu există evaluări
  • TW Lab5
    TW Lab5
    Document3 pagini
    TW Lab5
    Dan
    Încă nu există evaluări
  • TW Atestare
    TW Atestare
    Document4 pagini
    TW Atestare
    yamahahohnerc70
    Încă nu există evaluări
  • AC Lab 4
    AC Lab 4
    Document4 pagini
    AC Lab 4
    DanuIepuras
    Încă nu există evaluări
  • Laborator NR.2
    Laborator NR.2
    Document9 pagini
    Laborator NR.2
    Daniil
    Încă nu există evaluări
  • Lab MMC2
    Lab MMC2
    Document5 pagini
    Lab MMC2
    Maxim
    Încă nu există evaluări
  • SecrieruAndrei Amoo Lab5
    SecrieruAndrei Amoo Lab5
    Document6 pagini
    SecrieruAndrei Amoo Lab5
    andy secrieru
    Încă nu există evaluări
  • Rezolvarea Numerica A Sistemelor de Ecuatii Liniare
    Rezolvarea Numerica A Sistemelor de Ecuatii Liniare
    Document8 pagini
    Rezolvarea Numerica A Sistemelor de Ecuatii Liniare
    Valentin I. Marius
    Încă nu există evaluări
  • AI-191 Medinschi Ion SO4
    AI-191 Medinschi Ion SO4
    Document5 pagini
    AI-191 Medinschi Ion SO4
    Carolin
    Încă nu există evaluări
  • Laborator-3 MMC
    Laborator-3 MMC
    Document4 pagini
    Laborator-3 MMC
    Dan
    Încă nu există evaluări
  • Lab.4 FC
    Lab.4 FC
    Document6 pagini
    Lab.4 FC
    Cristina Florea
    Încă nu există evaluări
  • Lab2 MN CR-212 V14
    Lab2 MN CR-212 V14
    Document8 pagini
    Lab2 MN CR-212 V14
    Tabureanu Marian
    Încă nu există evaluări
  • Lucrarea de Laborator NR 7 POO
    Lucrarea de Laborator NR 7 POO
    Document7 pagini
    Lucrarea de Laborator NR 7 POO
    Alexandru Burdeniuc
    Încă nu există evaluări
  • Laborator 1 MMC
    Laborator 1 MMC
    Document9 pagini
    Laborator 1 MMC
    Cristian Popa
    Încă nu există evaluări
  • Laboratorul Nr1 La Grafica Pe Calculator Gc.
    Laboratorul Nr1 La Grafica Pe Calculator Gc.
    Document4 pagini
    Laboratorul Nr1 La Grafica Pe Calculator Gc.
    Ion Damaschin
    Încă nu există evaluări
  • Lab 4
    Lab 4
    Document4 pagini
    Lab 4
    Viktor Dobrovolschi
    Încă nu există evaluări
  • Sofroni Maxim Ai-211 MN Lab3
    Sofroni Maxim Ai-211 MN Lab3
    Document7 pagini
    Sofroni Maxim Ai-211 MN Lab3
    Максим Софрони
    Încă nu există evaluări
  • Lucrarea de Laborator NR 5 POO
    Lucrarea de Laborator NR 5 POO
    Document4 pagini
    Lucrarea de Laborator NR 5 POO
    Alexandru Burdeniuc
    Încă nu există evaluări
  • Laborator 1 C
    Laborator 1 C
    Document17 pagini
    Laborator 1 C
    Dorin Graur
    Încă nu există evaluări
  • NR 4
    NR 4
    Document7 pagini
    NR 4
    Graid Icen
    Încă nu există evaluări
  • Raport 3
    Raport 3
    Document11 pagini
    Raport 3
    Damean Alexandra
    100% (1)
  • CR-191 MIPI Axenti Alina Lab4
    CR-191 MIPI Axenti Alina Lab4
    Document6 pagini
    CR-191 MIPI Axenti Alina Lab4
    Alina Axenti
    Încă nu există evaluări
  • Lab 4 MMC
    Lab 4 MMC
    Document3 pagini
    Lab 4 MMC
    Adrian Bodorin
    Încă nu există evaluări
  • SOMIPP Lab4
    SOMIPP Lab4
    Document7 pagini
    SOMIPP Lab4
    Dan
    Încă nu există evaluări
  • SOMIPP Lab 5
    SOMIPP Lab 5
    Document5 pagini
    SOMIPP Lab 5
    Augusta Bucataru
    Încă nu există evaluări
  • Laboratorul 2 PPE
    Laboratorul 2 PPE
    Document4 pagini
    Laboratorul 2 PPE
    crismaruion
    Încă nu există evaluări
  • Programarea in Retea Lab 3 Iepuras Daniel TI-171
    Programarea in Retea Lab 3 Iepuras Daniel TI-171
    Document8 pagini
    Programarea in Retea Lab 3 Iepuras Daniel TI-171
    DanuIepuras
    Încă nu există evaluări
  • BDC Lucrare de Curs
    BDC Lucrare de Curs
    Document37 pagini
    BDC Lucrare de Curs
    Vladislav Crivenco
    Încă nu există evaluări
  • Ll1 Mmc1 Mereuta Ana Ti-192
    Ll1 Mmc1 Mereuta Ana Ti-192
    Document11 pagini
    Ll1 Mmc1 Mereuta Ana Ti-192
    Anya Mr
    Încă nu există evaluări
  • Lab 1 BD
    Lab 1 BD
    Document7 pagini
    Lab 1 BD
    Augusta Bucataru
    Încă nu există evaluări
  • AMOO Lab2.Use Case
    AMOO Lab2.Use Case
    Document5 pagini
    AMOO Lab2.Use Case
    Dorin Gribincea
    Încă nu există evaluări
  • LL2 Baze de Date
    LL2 Baze de Date
    Document15 pagini
    LL2 Baze de Date
    Anya Mr
    Încă nu există evaluări
  • Raport 6
    Raport 6
    Document3 pagini
    Raport 6
    Dekionlolz В
    Încă nu există evaluări
  • AMOO - Proiect de An
    AMOO - Proiect de An
    Document4 pagini
    AMOO - Proiect de An
    Dan
    Încă nu există evaluări
  • Iepuras Daniel LAB 3 TS
    Iepuras Daniel LAB 3 TS
    Document8 pagini
    Iepuras Daniel LAB 3 TS
    DanuIepuras
    Încă nu există evaluări
  • LFA Lab 1
    LFA Lab 1
    Document8 pagini
    LFA Lab 1
    Valeria Cebanu
    Încă nu există evaluări
  • Lab 2 POO AI-191
    Lab 2 POO AI-191
    Document8 pagini
    Lab 2 POO AI-191
    Carolin
    Încă nu există evaluări
  • Lab 3
    Lab 3
    Document13 pagini
    Lab 3
    Витёк Мужичёк
    100% (1)
  • Cap 3 POO
    Cap 3 POO
    Document47 pagini
    Cap 3 POO
    nicolau_f
    Încă nu există evaluări
  • LAB4
    LAB4
    Document6 pagini
    LAB4
    DorelDjj
    Încă nu există evaluări
  • LAB4-5 Croitoru Tudor
    LAB4-5 Croitoru Tudor
    Document27 pagini
    LAB4-5 Croitoru Tudor
    DorelDjj
    Încă nu există evaluări
  • Examen Final
    Examen Final
    Document23 pagini
    Examen Final
    DorelDjj
    Încă nu există evaluări
  • Laboratorul 4
    Laboratorul 4
    Document9 pagini
    Laboratorul 4
    DorelDjj
    Încă nu există evaluări
  • Laborator 4 Croitoru Tudor
    Laborator 4 Croitoru Tudor
    Document3 pagini
    Laborator 4 Croitoru Tudor
    DorelDjj
    Încă nu există evaluări
  • Croitoru Tudor Laborator 2
    Croitoru Tudor Laborator 2
    Document6 pagini
    Croitoru Tudor Laborator 2
    DorelDjj
    Încă nu există evaluări
  • Laborator 3 Croitoru Tudor
    Laborator 3 Croitoru Tudor
    Document8 pagini
    Laborator 3 Croitoru Tudor
    DorelDjj
    Încă nu există evaluări