Subiecte examen la disciplina de P.O.O.

grupa 10210 A, 2012

S1. (10 puncte)

1.1. Precizati tipurile de date pe care pot să le întoarcă constructorii.
1.2. Precizaţi diferenţa dintre un constructor implict şi un constructor cu parametri impliciţi. Care dintre
aceştia poate fi generat automat de către compilator ?
1.3. Ce diferenţe apar la redefinirea unei funcţii (obişnuite) comparativ cu redefinirea unei funcţii
virtuale?
1.4. Precizaţi structura unui constructor general.
1.5. Precizaţi ce reprezintă funcţiile de I/E de tip manipulator definite în C++ şi pentru ce se utilizează.

S2. (10 puncte) Fără a rula acest program, să se precizeze ce se va afişa pe ecran

# include <iostream.h>

class BAZA {
public: int m;
BAZA (int x) { m = x; cout << "Construiesc cl BAZA:" << " m = " << m << endl; }
};

class D1 : virtual public BAZA {

public: int n;
D1 (int x, int y) : BAZA (x) { n = y; cout << "Construiesc cl D1:" << " n = " << n << endl; }
int f() { return m + 2*n; }
};

class D2 : virtual public BAZA {

public: int k;
D2 (int x, int y) : BAZA (x) { k = y; cout << "Construiesc cl D2:" << " k = " << k << endl; }
int f() { return 2*m + k; }
};

class D3 : public D1, public D2 {

int p;
public: D3 (int x, int y, int z, int t) : BAZA (x), D1(y, z), D2(y, z)
{ p = t; cout << "Construiesc cl D3:" << " p = " << p << endl; }
int f() { return m+n+k+p; }
int g() { return p + f(); }
};

void main (void)

{ D3 Obd3 (2, 1, 3, 4); cout << Obd3.f() << '\n';
D3 Obd3a (3, 2, 1, 7); cout << Obd3a.m + Obd3a.n + Obd3a.k + Obd3a.g() << '\n';
}

1
S3. (Enunţ: 1p; Subiect: 9 puncte). Fără a rula acest program, să se precizeze ce se va afişa pe ecran.

# include <iostream.h>

class BAZA {
int i;
protected: void set (int x) { i = x; }
int read() { return 3*i; }
public: BAZA(int x = 0) { i = x; cout << "Trec prin constructorul clasei BAZA\n"; }
int valoare (int m) { return m + 2*i; }
};

class DERIV : public BAZA {

int j;
BAZA a, b; // Obiecte incluse in sectiunea privata
public: DERIV (int y, int z, int t): a(z), b(t) { j = y;
cout << "Trec prin constructorul clasei DERIV\n"; }
void schimba (int x) { set(x); }
int g() { return read(); }
int g1() { return valoare(1); }
int g2() { return j + a.valoare(2) + b.valoare(2);}
};

void main (void)

{ DERIV d(3, 2, 2);
d.schimba(1);
cout << d.g() << endl;
cout << d.g1() << endl;
cout << d.g()*d.g1() << endl;
cout << d.g()*d.g2() << endl;
}

2
S4. (Enunţ: 1p; Subiect: 9 puncte). Fără a rula acest program, să se precizeze ce se va afişa pe ecran.

# include <iostream.h>

class A {
int i;
public: A(int x) { i = x; cout << "Constructorul clasei A\n"; }
~A() {cout << "Destructorul clasei A\n";}
int f() { return 2*i; }
};

class B {
int i;
public:
B(int y) { i = y; cout << "Constructorul clasei B\n"; }
~B() {cout << "Destructorul clasei B\n";}
int f() { return 2*i;}
};

class C : public B {
B b;
public:
C(int z, int t) : B(z), b(t) { cout << "Constructorul clasei C\n"; }
~C() {cout << "Destructorul clasei C\n";}
int f() { return B::f(); }
int g() { return B::f() + b.f() + f(); }
};

void main (void)

{ { A a(3); cout << a.f() << endl; B b(2); cout << a.f()+b.f() << endl; }
{ C c(1, 2); cout << c.f() << " " << c.g() << endl; }
}

---------------------------------------------------

Timp de lucru: 2.5 ore

3
Răspunsuri:
S1.
1.1. Funcţiile de tip constructor (constructorii) nu pot întoarce nici o valoare. De aceea în corpul funcţiei nu trebuie
să apară instrucţiunea return.
1.2. Constructorii impliciţi nu au argumente, fiind, în cazul unei clase cu numele X, de forma următoare: X(void).
Aceştia, pot fi generaţi automat de compilator în cazul în care o clasă nu are constructori. Constructorii cu
parametrii impliciţi au argumente cu valori implicite.
1.3. O funcţie redefinită trebuie să difere în tip şi/sau în număr de parametri. O funcţie virtuală redefinită trebuie să
aibă acelaşi tip şi număr de parametri şi aceeaşi valoare de retur. În plus, funcţiile virtuale trebuie să fie funcţii
membre ale unei clase, ceea ce nu este absolut necesar în cazul funcţiilor redefinite. Din cauza acestor diferenţe,
pentru a descrie redefinirea funcţiilor virtuale se foloseşte termenul overriding (suprapunere).
1.4. Notând cu X numele clasei curente şi cu T1, T2,…, tipurile de date ale argumentelor, un constructor general
are declaraţia de forma: X(T1, T2, ...) {...};
1.5. Manipulatorii sunt funcţii speciale de formatare a informaţiilor în operaţiilor de I/E. Aceştia sunt asociaţi unui
stream şi pot să apară în unele instrucţiuni de I/E schimbând starea sream-ului respectiv.

S2.
Construiesc clasa BAZA: m = 2
Construiesc clasa D1: n = 3
Construiesc clasa D2: k = 3
Construiesc clasa D3: p = 4
12
Construiesc clasa BAZA: m = 3
Construiesc clasa D1: n = 1
Construiesc clasa D2: k = 1
Construiesc clasa D3: p = 7
24

S3. Se afisează:
Trec prin constructorul clasei BAZA
Trec prin constructorul clasei BAZA
Trec prin constructorul clasei BAZA
Trec prin constructorul clasei DERIV
3
3
9
45

S4. Se afisează:
Constructorul clasei A
6
Constructorul clasei B
10
Destructorul clasei B
Destructorul clasei A

Constructorul clasei B
Constructorul clasei B
Constructorul clasei C
2 8
Destructorul clasei C
Destructorul clasei B
Destructorul clasei B