1. a) Membrii publici sunt vizibili din toate clasele.

Membrii privati sunt vizibili doar in interiorul clasei de care apartin (inclusiv membrilor apartinand acelei clase). Membrii protected sunt vizibili doar in interiorul clasei carei apartin si in interiorul tuturor subclaselor acelei clasei. b) O functie friend este acea functie care are acces la datele private + protected ale unei clase. c) La crearea obiectului de tip Y, primul constructor executat va fi cel al obiectului de tip X, iar la distrugerea obiectului de tipY, primul destructor executat va fi cel al obiectului de tip Y.

2. a) template <class T> T sum (T a[], int n) { T result=0; while(n) { result += a[--n]; } return (result); } b) In primul rand corpul clasei A trebuia declarat intre acolade { si nu intre paranteze (!!! Deci ipoteza este gresita! Pff. In fine, consideram o ipoteza valabila, folosind acoladele. ii. va da eroare pentru ca membrul y al clasei A nu este accesibil. iii. va da o eroare de sintaxa (nu trebuia sa se foloseasca () dupa public A A nu este o functie). E cod ambiguu oricum, plin de erori de sintaxa.

3. a) class Vect { private: int size; double *elemente; public: // constructorul implicit Vect() { size=0; } // constructorul cu parametri (sau parametru?) Vect(int _size) { size=_size; elemente = (double *)malloc (sizeof(double)*_size); } // destructorul ~Vect() { free(elemente); } }; b) Vect operator+(double x) { int i; Vect y(size); for(i=0;i<size;i++) { y.elemente[i]+=x; } return y; } Vect operator*(double x) { int i;

Vect y(size); for(i=0;i<size;i++) { y.elemente[i]*=x; } return y; } c) Vect operator+(Vect x) { int i; Vect y(size); if (x.size != size) { // nu au aceeasi dimensiune return NULL; } for(i=0;i<size;i++) { y.elemente[i]=elemente[i]+x.elemente[i]; } return y; } Vect operator*(Vect x) { int i; Vect y(size); if (x.size != size) { // nu au aceeasi dimensiune return NULL; } for(i=0;i<size;i++) { y.elemente[i]=elemente[i]*x.elemente[i]; } return y; }

4. a) // Se adauga urmatoarele functii in interiorul clasei Vect int element(int x) { return elemente[x]; } void set_element(int index, int value) { elemente[index] = value; } int Size() { return size; } // In clasa Matr se adauga functia pentru produs double prod (int i, int j) { double result=0; int k; for (k=0;k<v[i]->Size();k++) { result += v[i]->element(i) + v[j]->element(i); } return result; } b) // constructorul implicit Matr () { v[0] = new Vect(3); v[1] = new Vect(3); v[2] = new Vect(3); } // constructorul cu parametri Matr (int _size) { v[0] = new Vect(_size); v[1] = new Vect(_size); v[2] = new Vect(_size); }

c) // declaram clasa Vect, pentru vectori class Vect { private: // date private int size; // dimensiunea vectorului double *elemente; // pointerul pentru valorile elementelor public: // constructorul implicit Vect() { size=0; } ~Vect() // destructor { free(elemente); } // constructorul cu parametri (sau parametru?) Vect(int _size) { size=_size; // initializam lungimea elemente = (double *)malloc (sizeof(double)*_size); // alocam memorie for (int i=0;i<_size;i++) { // setam elementele ca fiind implicit primele _size numere naturale elemente[i] = i; } } Vect operator+(double x) // supraincarcarea operatorului + { int i; // un contor Vect y(size); // vectorul pentr rezultat for(i=0;i<size;i++) // adunarea efectiva { y.elemente[i]+=x; } return y; } Vect operator+(Vect x) // supraincarcarea + pentru doi vectori { int i; Vect y(size);

if (x.size != size) // daca dimensiunea lor este diferita { // nu au aceeasi dimensiune return NULL; } for(i=0;i<size;i++) // adunarea efectiva { y.elemente[i]=elemente[i]+x.elemente[i]; } return y; } int element(int x) // functie care intoarce elementul de la pozitia x { return elemente[x]; } // seteaza valoarea pentru elementul de la pozitia index cu valoarea value void set_element(int index, int value) { elemente[index] = value; } int Size() // intoarce dimensiunea vectorului { return size; } }; // clasa pentru matrice class Matr { public: Vect *v[3]; // un membru de tip vector cu 3 obiecte (3 vectori) // constructorul implicit Matr () { v[0] = new Vect(3); // vector cu 3 elemente v[1] = new Vect(3); v[2] = new Vect(3); } // constructorul cu parametri Matr (int _size)

{ v[0] = new Vect(_size); v[1] = new Vect(_size); v[2] = new Vect(_size); } // initializarea matricii declararea fiecarei linii ca avand nr_coloane coloane Matr (int nr_linii, int nr_coloane) { for (int i=0;i<nr_linii;i++) { v[i] = new Vect(nr_coloane); } } // functie pentru setarea valorii pentr un element de la linia x, coloana y void set_element(int x, int y, int value) { v[x]->set_element(y,value); } // functia pentru produsul dintre doua linii double prod (int i, int j) { double result=0; int k; for (k=0;k<v[i]->Size();k++) { result += v[i]->element(i) + v[j]->element(i); } return result; } }; //--------------------------------------------------------------------------int main() { Matr m(3,4); // declararea unei matrice de 3x4 int i; // contor double nr; // o variabila ajutatoare for (i=0;i<3*4;i++) { cout << "Introduceti matrice[" << i/3 << "][" << i%4 << "]: "; cin >> nr; m.set_element (i/3, i%4, nr); // adaugarea numarului citit in matrice }

cout << m.prod(1,2); getch(); return 0; }

Gata.

GIVE PEACE A CHANCE!

http://www.youtube.com/watch?v=I-NRriHlLUk