Subiecte examen la disciplina de P.O.O.

, grupa 10201 A, 2012

S1. (Enunţ: 1p; Subiect: 9 puncte)

1.1. Ce înţelegeti prin funcţii de tip in-line şi ce operaţii efectuează compilatorul la întâlnirea unei astfel
de funcţii ?
1.2. Ce înţelegeţi prin indicator de format defiiţi în C++ şi pentru ce se utilizează ?
1.3. Care este durata de viaţă a obiectelor de tip static ?
1.4. Ce diferenţe apar la redefinirea unei funcţii (obişnuite) comparativ cu redefinirea unei funcţii
virtuale?
1.5. Ce înţelegeţi prin clase parametrizate ?.

S2. (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 B {
public: int a, b;
B (int x, int y) { a = x; b = y; cout << "Constructor cl B:" << " a = " << a << " b = " << b << endl; }
};
class D1 : virtual public B {
public: D1 (int x, int y) : B (x, y) { cout << "Constructor cl D1:" << endl; }
int f() { return a + b; }
};

class D2 : virtual public B {

public: int k;
D2 (int x, int y, int z) : B (x, y) { k = z; cout << "Constructor cl D2:" << " k = " << k << endl; }
int f() { return a * b * k; }
int g() { return k + f(); }
};

class D3 : public D1, public D2 {

int u;
public: D3 (int x, int y, int z, int t) : B(x, y), D1(x, y), D2(x, y, z)
{ u = t; cout << "Constructor cl D3:" << " u = " << u << endl; }
int f() { return a + b + k + u; }
int g() { return u + f(); }
};

void main (void)

{ D3 OB1 (2, 1, 2, 1); cout << OB1.f() << '\n';
D1 OBD1(2, 3); cout << OBD1.f() << endl;
D2 OBD2(1, 2, 3); cout << OBD2.f() << “ “ << OBD2.g() << endl;
D3 OB2 (3, 3, 1, 1); cout << OB2.a + OB2.b + OB2.k + OB2.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 A {
int n;
public:
int N() const { return n; }
void g() { cout << "Functia g in clasa A" << endl; }
A(int k = 0) { n = k; cout << "Constructorul clasei A" << endl; } // Constructorul clasei A
};

class B {
double q;
public:
double Z() const { return q; }
void f() { cout << "Functia f in clasa B" << endl; }
void g() { cout << "Functia g in clasa B" << endl; }
B(double k = 10) { q = k; cout << "Constructorul clasei B" << endl; } // Constructorul clasei B
};

class X { // Clasa compusa

char c;
A a;
B b;
public:
void f() { b.B::f(); } // Functia f in clasa X
void ga() { a.A::g(); }
void gb() { b.B::g(); }
X() : a(5), b(5.3), c('x') { cout << "Constructorul clasei X" << endl;}
int Xn() { cout << "n = " << a.N() << endl;}
double Zq() { cout << "q =" << b.Z() << endl;}
char Xc() { cout << "c = " << c << endl;}
};

void main() {
X x; A a(5); B b(5.3);
x.f(); x.ga(); x.gb(); x.Xn(); x.Zq();
x.Xc();
}

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(2); cout << a.f() << endl; B b(3); cout << a.f()+b.f() << endl; }
{ C c(2, 2); cout << c.f() << " " << c.g() << endl; }
}

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

Timp de lucru: 2.5 ore

3
 Răspunsuri:

S1. Constructorul clasei A

1.1. Limbajul C++ oferă posibilitatea expandării Constructorul clasei B
inline a funcţiilor. Expandarea inline înseamnă Functia f in clasa B
generarea de către compilator a codului corespunzător Functia g in clasa A
funcţiei, fără să se mai genereze o secvenţă de apel. Functia g in clasa B
1.2. Pentru formatarea datelor în scopul afişării sau n=5
citirii acestora, fiecare stream din C++ are asociat un q = 5.3
număr de “indicatori de format“ (flags) codificaţi într- c=3
o variabilă de tip long int.
S4. Se afisează:
1.3. Deoarece aceste obiecte sunt locale pentru o Constructorul clasei A
anumita funcţie, rezultă că, durata de viaţă a acestor 4
obiecte este durata de viaţă a funcţiei. Dacă o funcţie Constructorul clasei B
conţine blocuri, obiectele create în interiorul acestor 10
blocuri, vor “vieţui“ numai în interiorul acestor Destructorul clasei B
blocuri. Locul de păstrare a obiectelor automate este Destructorul clasei A
stiva.
1.4. O funcţie redefinită trebuie să difere în tip şi/sau Constructorul clasei B
în număr de parametri. O funcţie virtuală redefinită Constructorul clasei B
trebuie să aibă acelaşi tip şi număr de parametri şi Constructorul clasei C
aceeaşi valoare de retur. În plus, funcţiile virtuale 4 12
trebuie să fie funcţii membre ale unei clase, ceea ce Destructorul clasei C
nu este absolut necesar în cazul funcţiilor redefinite. Destructorul clasei B
Din cauza acestor diferenţe, pentru a descrie Destructorul clasei B
redefinirea funcţiilor virtuale se foloseşte termenul
overriding (suprapunere).
1.5. Parametrizarea datelor reprezintă un element
important al paradigmei abstractizării datelor şi
permite definirea unor clase care conţin tipuri de
date nespecificate complet.

S2. Ex 01_11.cpp
Construiesc cl B: a = 2 b = 1
Construiesc cl D1:
Construiesc cl D2: k = 2
Construiesc cl D3: u = 1
6
Construiesc cl B: a = 2 b = 3
Construiesc cl D1:
5
Construiesc cl B: a = 1 b = 2
Construiesc cl D2: k = 3
6 9
Construiesc cl B: a = 3 b = 3
Construiesc cl D1:
Construiesc cl D2: k = 1
Construiesc cl D3: u = 1
16

S3. Se afişează:
Constructorul clasei A
Constructorul clasei B
Constructorul clasei X