-
Notifications
You must be signed in to change notification settings - Fork 19
Programare Orientată pe Obiecte
Salt rapid
| 2005 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2006 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 |
| 2007 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 |
| 2008 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 |
| 2009 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 |
1. Spuneți de câte ori se execută fiecare constructor în programul de mai jos și în ce ordine.
#include <iostream.h>
class cls1
{
protected:
int x;
public:
cls1() { x = 13; }
};
class cls2: public cls1
{
int y;
public:
cls2() { y = 15; }
int f(cls2 ob) { return ob.x + ob.y; }
};
int main()
{
cls2 ob;
cout << ob.f(ob);
return 0;
}2. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, altfel, spuneți de ce nu este corect.
#include <iostream.h>
class cls1
{
int x;
public:
cls1(){ x = 13; }
int g()
{
static int i;
i++;
return i + x;
}
};
class cls2
{
int x;
public:
cls2() { x = 27; }
cls1& f()
{
static cls1 ob;
return ob;
}
};
int main()
{
cls2 ob;
cout << ob.f().g();
return 0;
}3. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, altfel, spuneți de ce nu este corect.
#include <iostream.h>
class cls1
{
protected:
int x;
public:
cls1(int i = 10) { x = i; }
int get_x() { return x; }
};
class cls2: cls1
{
public:
cls2(int i) : cls1(i) {}
};
int main()
{
cls d(37);
cout << d.get_x();
return 0;
}4. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, altfel, spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int x;
public:
cls(int y) { x = y; }
int operator*(cls a, cls b) {return a.x * b.x; }
};
int main()
{
cls m(100), n(15);
cout << m*n;
return 0;
}5. Cum trebuie definită variabila n din clasa de mai jos, dacă dorim ca ea să contorizeze numărul tuturor obiectelor care aparțin clasei cls la un moment dat?
class cls
{
int n;
public:
cls() { n++; }
~cls() { n--; }
};6. Fiind date următoarele tipuri de clase:
class B { /* instructiuni */ };
class D1: virtual B { /* instructiuni */ };
class D2: virtual B { /* instructiuni */ };
class D3: B { /* instructiuni */ };
class D4: private B { /* instructiuni */ };
class D5: virtual public B { /* instructiuni */ };
class M1: D1, public D2, D3, private D4, virtual D5
{ /* instructiuni */ };
class M2: D1, D2, virtual D3, virtual D4, virtual D5
{ /* instructiuni */ };spuneți de câte ori este moștenită clasa B în clasa M1. Dar în clasa M2? Justificați.
7. Spuneți care dintre declarațiile funcției main() sunt corecte în programul de mai jos. Justificați.
#include <iostream.h>
class B1
{
public:
int x;
};
class B2
{
int y;
};
class B3
{
public:
int z;
};
class B4
{
public:
int t;
};
class D: private B1, protected B2, public B3, B4
{
int u;
};
int main()
{
D d;
cout << d.u;
cout << d.x;
cout << d.y;
cout << d.z;
cout << d.t;
return 0;
}8. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int vi;
public:
cls(int v = 37) { vi = v; }
friend int& f(cls);
};
int& f(cls c)
{
return c.vi;
}
int main()
{
const cls d(15);
f(d) = 8;
cout << f(d);
return 0;
}9. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, altfel, spuneți de ce nu este corect.
#include <iostream.h>
class cls1
{
public:
int x;
cls1(int i = 20) { x = i; }
};
class cls2
{
public:
int y;
cls2(int i = 30) { y = i; }
operator cls1()
{
cls1 ob;
ob.x = y;
return ob;
}
};
cls1 f(cls1 ob)
{
ob.x++;
return ob;
}
int main()
{
cls1 ob1;
f(ob1);
cout << ob1.x;
cls2 ob2;
f(ob2);
cout << ob2.y;
return 0;
}10. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, altfel, spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int x;
public:
cls(int i = 25) { x = i; }
int f();
};
int cls::f() { return x; }
int main()
{
const cls d(15);
cout << d.f();
return 0;
}11. Spuneți de câte ori se apelează destructorul clasei cls în programul de mai jos. Justificați.
#include <iostream.h>
class cls
{
public:
int x;
cls(int i = 0) { x = i; }
};
cls f(cls c)
{
c.x++;
return c;
}
int main()
{
cls r(10);
cls s = f(r);
return 0;
}12. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
template <class tip>
tip dif(tip x, tip y)
{
return x-y;
}
unsigned dif(unsigned x, unsigned y)
{
return x >= y ? x-y : y-x;
}
int main()
{
unsigned i=7, j=8;
cout << dif(i,j);
return 0;
}13. Spuneți dacă programul de mai jos este corect. În caz afirmativ, precizați exact constructorii care se execută și în ce ordine. În caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls1
{
public:
int x;
cls1(int i = 13) { x = i; }
};
class cls2: virtual public cls1
{
public:
cls2(int i = 15) { x = i; }
};
class cls3: virtual public cls1
{
public:
cls3(int i = 17) { x = i; }
};
class cls4: public cls1
{
public:
cls4(int i = 19) { x = i; }
};
class cls5: public cls2, public cls3, public cls4
{
public:
int y;
cls5(int i, int j) : cls4(i), cls2(j)
{
y = i + j;
}
cls5(cls5& ob)
{
y = -ob.y;
}
};
int main()
{
cls5 ob1(-9,3), ob2 = ob1;
cout << ob2.y;
return 0;
}14. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int x;
const int y;
public:
cls(int i, int j) : x(i), y(j) {}
int imp(int, int) const;
};
int imp(int i, int j) const
{
x = i;
y = j;
return x+y;
}
int main()
{
cls ob(5);
cout << ob.imp(-9,8);
return 0;
}15. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
int a;
public:
B(int i=0) { a = i; }
int get_a() { return a; }
};
class D: private B
{
public:
D(int x=0) : B(x) {}
int get_a() { return B::get_a(); }
};
int main()
{
D d(-89);
cout << d.get_a();
return 0;
}16. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
protected:
int x;
B(int i = 10) { x = i; }
public:
virtual B operator+(B ob)
{
B y(x + ob.x);
return y;
}
};
class D: public B
{
public: D(int i = 10) { x = i; }
void operator=(B p) { x = p.x; }
B operator+(B ob)
{
B y(x + ob.x + 1);
return y;
}
void afisare() { cout << x; }
};
int main()
{
D p1(-59), p2(32), *p3=new D;
*p3=p1+p2;
p3->afisare();
return 0;
}17. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
public:
int sa;
cls(int s = 0) { sa = s; }
operator int() { return sa; }
int f(int c) { return sa * (1 + c/100); }
};
int main()
{
cls p(37);
cout << p.f(p);
return 0;
}18. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
public:
int x;
B(int i = 0) { x = i; }
virtual B aduna(B ob) { return x + ob.x; }
B minus() { return 1-x; }
void afisare(){ cout << x; }
};
class D: public B
{
public:
D(int i = 0) { x = i; }
B aduna(B ob) { return x + ob.x + 1; }
};
int main()
{
B *p1, *p2;
p1 = new D(138);
p2 = new B(-37);
*p2 = p2->aduna(*p1);
*p1 = p2->minus();
p1->afisare();
return 0;
}19. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
template <class tip>
class cls
{
tip z;
public: cls(tip i) { z = i; }
tip operator-(cls);
};
template <class tip>
tip cls<tip>::operator-(cls<tip> a)
{
return z - a.z;
}
template <class tip>
tip dif(tip x, tip y)
{
return x - y;
}
int dif(int x, int y)
{
return x >= y ? x-y : y-x;
}
int main()
{
cls<int> i=3; cls<float> j=4;
cout << dif(i,j);
return 0;
}20. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
static int x;
public:
cls(int i = 25) { x = i; }
friend int& f(cls);
};
int cls::x = -13;
int& f(cls c)
{
return c.x;
}
int main()
{
cls d(15);
cout<<f(d);
return 0;
}21. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int v, nr;
public:
cls(int i)
{
nr = i;
v = new int[i];
}
friend int& operator[](int);
friend ostream& operator<<(ostream&, cls);
};
int& operator[](cls& x, int i)
{
return x.v[i];
}
ostream& operator<<(ostream& o, cls x)
{
for(int i=0; i<x.nr; i++)
cout << x.v[i] <<" ";
return o;
}
int main()
{
cls x(10);
x[5] = 7;
cout << x;
return 0;
}22. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
static int i;
int j;
public:
cls(int x=7) { j = x; }
static int imp(int k)
{
cls a;
return i + k + a.j;
}
};
int cls::i;
int main()
{
int k=5;
cout << cls::imp(k);
return 0;
}23. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int x;
public:
cls(int i = 32) { x = i; }
int f() const;
};
int cls::f() const
{
return x++;
}
void main()
{
const cls d(-15);
cout << d.f();
}24. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează pentru o valoare întreagă citită egală cu 7, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
float f(float f)
{
if(f) throw f;
return f/2;
}
int main()
{
int x;
try
{
cout << "Da-mi un numar intreg: ";
cin >> x;
if(x) f(x);
else throw x;
cout << "Numarul " << x << " e bun!" << endl;
}
catch (int i)
{
cout << "Numarul " << i << " nu e bun!" << endl;
}
return 0;
}25. Spuneți de câte ori se apelează fiecare constructor în programul de mai jos și în ce ordine.
class cls1
{
protected:
int x;
public:
cls1() { x = 13; }
};
class cls2: public cls1
{
protected:
int y;
public:
cls2() { y = 15; }
};
class cls3: public cls2
{
protected:
int z;
public:
cls3() { z = 17; }
int f(cls3 ob) { return ob.x + ob.y + ob.z; }
};
int main()
{
cls3 ob;
ob.f(ob);
return 0;
}26. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int x;
public:
cls() { x = 23; }
int get_x(){ return x; }
};
int main()
{
cls *p1, *p2;
p1 = new cls;
p2 = (cls*) malloc(sizeof(cls));
int x = p1->get_x() + p2->get_x();
cout << x;
return 0;
}27. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
int a;
B(int i=0) { a = i; }
int get_a() { return a; }
};
class D: protected B
{
public:
D(int x=0): B(x) {}
int get_a() { return B::get_a(); }
};
int main()
{
D d(-89);
cout << d.get_a();
return 0;
}28. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls1
{
public:
int a;
cls1() { a = 7; }
};
class cls2
{
public:
int b;
cls2(int i) { b = i; }
cls2(cls1 &x) { b = x.a; }
};
int main()
{
cls1 x;
cout << x.a;
cls2 y(x);
cout << y.b;
return 0;
}29. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
public:
int sa;
cls(int s=0) { sa = s; }
operator float() { return sa; }
};
int f(float c)
{
return c * (1 + c/100);
}
int main()
{
cls p(35);
cout << f(p);
return 0;
}30. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
protected:
int x;
public:
B() { x = 78; }
};
class D1: virtual public B
{
public:
D1() { x = 15; }
};
class D2: virtual public B
{
public:
D2() { x = 37; }
};
class C: public D2, public D1
{
public:
int get_x() { return x; }
};
int main()
{
C ob;
cout << ob.get_x();
return 0;
}31. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
template <class tip>
class cls
{
tip z;
public:
cls(tip i) { z = i; }
tip operator-(cls a) { return z - a.z; }
int operator>=(cls a) { return z >= a.z; }
};
template <class tip>
tip dif(tip x, tip y)
{
return x-y;
}
int dif(cls<int> x, cls<float> y)
{
return x >= y ? x-y : y-x;
}
int main()
{
cls<int> i = 3; cls<float> j = 4;
cout << dif(i, j);
return 0;
}32. Spuneți de câte ori se apelează destructorul clasei cls în programul de mai jos. Justificați.
class cls
{
int x;
public:
cls(int i=0) { x = i; }
cls(cls &ob) { x = ob.x; }
};
cls& f(cls &c)
{
return c;
}
main()
{
cls r;
cls s = r;
f(f(f(s)));
}33. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
int x;
public:
B(int i=0) { x = i; }
};
class D: public B
{
public:
D() : B(15) {}
int f() { return x; }
};
int main()
{
D d;
cout << d.f();
return 0;
}34. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
static int i;
int j;
public:
cls(int x=7) { j = x; }
static int imp(int k)
{
cls a;
return i + k + a.j;
}
};
int cls::i;
int main()
{
int k=5;
cout << cls::imp(k);
return 0;
}35. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int x;
public:
cls(int i=32) { x = i; }
int f() const { return x++; }
};
void main()
{
const cls d(-15);
cout << d.f();
}36. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează pentru o valoare întreagă citită egală cu 7, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
float f(int y)
{
try
{
if (y % 2) throw y/2;
}
catch(int i)
{
if (i % 2) throw;
cout << "Numarul " << i << " nu e bun!" <<endl;
}
return y/2;
}
int main()
{
int x;
try
{
cout << "Da-mi un numar intreg: ";
cin >> x;
if(x)
{
f(x);
}
cout << "Numarul " << x << " nu e bun!" << endl;
}
catch (int i)
{
cout << "Numarul " << i << " e bun!" << endl;
}
return 0;
}37. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
int x;
public:
B(int i = 2) : x(i) {}
int get_x() const { return x; }
};
class D: public B
{
int *y;
public:
D(int i = 2) : B(i)
{
y = new int[i];
for(int j=0; j<i; j++)
y[j] = 1;
}
D(D& a)
{
y= new int[a.get_x()];
for(int i=0; i<a.get_x(); i++)
y[i] = a[i];
}
int& operator[](int i) { return y[i]; }
};
ostream& operator<<(ostream& o, const D& a)
{
for(int i=0; i<a.get_x(); i++) o << a[i];
return o;
}
int main()
{
D ob(5);
cout << ob;
return 0;
}38. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
int x;
public:
B(int i = 10) { x = i; }
int get_x() { return x; }
};
class D: public B
{
public:
D(int i) : B(i) {}
D operator+(const D& a) {return x + a.x; }
};
int main()
{
D ob1(7), ob2(-12);
cout << (ob1 + ob2).get_x();
return 0;
}39. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
public:
int x;
B(int i = 16) { x = i; }
B f(B ob) { return x + ob.x; }
};
class D: public B
{
public:
D(int i = 25) { x = i; }
B f(B ob) { return x + ob.x + 1; }
void afisare(){ cout << x; }
};
int main()
{
B *p1 = new D, *p2 = new B, *p3 = new B(p1->f(*p2));
cout << p3->x;
return 0;
}40. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int *v, nr;
public:
cls(int i)
{
nr = i;
v = new int[i];
for(int j=1; j<nr; j++)
v[j] = 0;
}
int size() { return nr; }
int& operator[](int i) { return *(v+i); }
};
int main()
{
cls x(10);
x[4] = -15;
for(int i=0; i<x.size(); i++)
cout << x[i];
return 0;
}41. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int x;
public:
cls(int i = -20) { x=i; }
const int& f(){ return x; }
};
int main()
{
cls a(14);
int b=a.f()++;
cout<<b;
return 0;
}42. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
static int x;
int i;
public:
B()
{
x++;
i=1;
}
~B() { x--; }
static int get_x() { return x; }
int get_i() { return i; }
};
int B::x;
class D: public B
{
public:
D() { x++; }
~D() { x--; }
};
int f(B *q)
{
return q->get_i() + 1;
}
int main()
{
B *p = new B;
cout << f(p);
delete p;
p = new D;
cout << f(p);
delete p;
cout << D::get_x();
return 0;
}43. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
int x;
public:
B(int i = 17) { x = i; }
int get_x() { return x; }
operator int() { return x; }
};
class D: public B
{
public:
D(int i=-16):B(i) {}
};
int main()
{
D a;
cout << 27+a;
return 0;
}44. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
static int x;
public:
cls (int i=1) { x = i; }
cls f(cls a) { return x + a.x; }
static int g() { return f()/2; }
};
int cls::x = 7;
int main()
{
cls ob;
cout << cls::g();
return 0;
}45. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int *v, nr;
public:
cls(int i=0)
{
nr = i;
v = new int[i];
for (int j = 0; j < size(); j++)
v[j] = 3 * j;
}
~cls() { delete[] v; }
int size() { return nr; }
int& operator[](int i) { return v[i]; }
cls operator+(cls);
};
cls cls::operator+(cls y)
{
cls x(size());
for (int i = 0; i < size(); i++)
x[i] = v[i] + y[i];
return x;
}
int main()
{
cls x(10), y=x, z;
x[3] = y[6] = -15;
z = x + y;
for(int i = 0; i < x.size(); i++)
cout << z[i];
return 0;
}46. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class B
{
int i;
public:
B() { i = 1; }
int get_i() { return i; }
};
class D: public B
{
int j;
public:
D() { j = 2; }
int get_j() { return j; }
};
int main()
{
B *p;
int x=0;
if(x) p = new B;
else p = new D;
if (typeid(p).name() == "D*")
cout << ((D*) p)->get_j();
return 0;
}47. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class cls
{
int x;
public:
cls(int i) { x = i; }
int set_x(int i)
{
int y = x;
x = i;
return y;
}
int get_x() { return x; }
};
int main()
{
cls *p = new cls[10];
int i=0;
for(; i<10; i++)
p[i].set_x(i);
for(i=0; i<10; i++)
cout << p[i].get_x(i);
return 0;
}48. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
template<class T>
int f(T x, T y)
{
return x+y;
}
int f(int x, int y)
{
return x-y;
}
int main()
{
int a=5;
float b=8.6;
cout << f(a,b);
return 0;
}49. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
int x;
public:
A(int i=0) { x = i; }
A operator+(const A& a) { return x + a.x; }
template <class T>
friend ostream& operator<<(ostream&,T);
};
template <class T>
ostream& operator<<(ostream& o, T t)
{
o << t.x;
return o;
}
int main()
{
A a1(33), a2(-21);
cout << a1+a2;
return 0;
}50. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
protected:
int x;
public:
A(int i=-31) { x = i; }
virtual A operator+(A a) { return x + a.x; }
};
class B: public A
{
public:
B(int i=12) { x = i; }
B operator+(B b) { return x + b.x + 1; }
void afisare(){ cout << x; }
};
int main()
{
A *p1 = new B, *p2 = new A;
B *p3 = new A(p2->operator+(*p1));
p3->afisare();
return 0;
}51. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
int x;
static int y;
public:
A(int i, int j) : x(i), y(j) {}
int f() const;
};
int A::y;
int A::f() const { return y; }
int main()
{
const A a(21,2);
cout << a.f();
return 0;
}52. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
int *v, dim;
public:
A(int i)
{
dim = i;
v = new int[dim];
for(int j=0; j<dim; j++)
v[j] = j;
}
A(A& a)
{
dim = a.dim;
v = new int[dim];
for(int j=0; j<dim; j++)
v[j] = a.v[j];
}
~A() { delete[] v; }
int size() { return dim; }
int& operator[](int i) { return v[i]; }
A operator+(A a1);
};
A A::operator+(A a1)
{
A a2(0);
a2.dim = dim;
v = new int[a2.dim];
for(int j=0; j<a2.dim; j++)
a2.v[j] = v[j] + a1.v[j];
return a2;
}
ostream& operator<<(ostream& o, A a)
{
for(int i=0; i<a.size(); i++)
cout << a[i] << " ";
return o;
}
int main()
{
A a(10), b(10), c(10);
c = a+b;
cout << c;
return 0;
}53. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A;
class B
{
int x;
public:
B(int i=107) { x = i; }
operator A();
};
B::operator A() { return x; }
class A
{
int x;
public:
A(int i=6) { x = i; }
int get_x() { return x; }
};
int main()
{
B b;
A a = b;
cout << a.get_x();
return 0;
}54. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
int x;
public:
A(int i=0) : x(i) {}
int get_x() { return x; }
int& set_x(int i) { x = i; }
};
A operator=(A a1, A a2)
{
a1.set_x(a2.get_x());
return a2;
}
int main()
{
A a(212), b;
cout << (b=a).get_x();
return 0;
}55. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
public:
int x;
A(int i=0) { x = i; }
virtual A minus() { return 1-x; }
};
class B: public A
{
public:
B(int i=0) { x = i; }
void afisare() { cout << x; }
};
int main()
{
A *p1 = new B(18);
*p1 = p1->minus();
p1->afisare();
return 0;
}56. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
int x, *y;
public:
A(int i)
{
x = i;
y = new int[x];
}
A(A& a)
{
x = a.x;
y = new int[x];
}
int get_x() const { return x; }
};
int f(A a) { return a.get_x(); }
int main()
{
const A a(5);
cout << (a.get_x() == f(a));
return 0;
}57. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
protected:
int x;
public:
A(int i=14) { x=i; }
};
class B: A
{
public:
B(B& b) { x = b.x; }
void afisare() { cout<<x; }
};
int main()
{
B b1, b2(b1);
b2.afisare();
return 0;
}58. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
class A
{
public:
int x;
A(int i=-13) { x = i; }
};
class B: virtual public A
{
public:
B(int i=-15) { x = i; }
};
class C: virtual public A
{
public:
C(int i=-17) { x = i; }
};
class D: virtual public A
{
public:
D(int i=-19) { x = i; }
};
class E: public B, public C, public D
{
public:
int y;
E(int i, int j) : D(i), B(j) { y = x + i + j; }
E(E& ob) { y = ob.x + ob.y; }
};
int main()
{
E e1(-21,2), e2 = e1;
cout << e2.y;
char c;
cin >> c;
return 0;
}59. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează pentru o valoare întreagă citită egală cu -35, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
int f(int y)
{
if (y<0)
throw y;
return y/2;
}
int main()
{
int x;
try
{
cout << "Da-mi un numar par: ";
cin >> x;
if(x % 2)
x = f(x);
else
throw x;
cout << "Numarul " << x << " e bun!" << endl;
}
catch (int i)
{
cout << "Numarul " << i << " nu e bun!" << endl;
}
return 0;
}60. Spuneți dacă programul de mai jos este corect. În caz afirmativ, spuneți ce afișează, în caz negativ spuneți de ce nu este corect.
#include <iostream.h>
template<class T>
T f(T x, T y)
{
return x+y;
}
int f(int x, int y)
{
return x-y;
}
int main()
{
int *a = new int(3), *b = new int(23);
cout << f(a,b);
return 0;
}1. Descrieți trei metode de proiectare diferite prin care elementele unei clase se pot regăsi în
dublu exemplar, sub diverse forme, în definiția altei clase.
2. Spuneți ce este obiectul implicit al unei metode și descrieți pe scurt proprietățile pe care le
cunoașteți despre acesta.
3. Descrieți pe scurt moștenirea virtuală și scopul în care este folosită.
4. Enumerați 3 metode de implementare a polimorfismului de compilare.
5. Descrieți pe scurt mecanismul de tratare a excepțiilor.
6. Descrieți pe scurt diferența dintre un pointer și o referință.
7. Descrieți pe scurt diferența dintre funcțiile care returnează
valoare și cele care returnează referință.
8. Descrieți pe scurt cum se pot defini funcții de conversie între tipuri (clase).
9. Spuneți care este diferența dintre clasa generică (template) și clasa abstractă și în
ce situații se folosește fiecare dintre ele.
10. Descrieți pe scurt diferența dintre transferul prin valoare și transferul prin
referință al parametrilor în cazul apelului unei funcții.
11. Spuneți pe scurt prin ce se caracterizează o metodă statică a unei clase.
12. Spuneți care este diferența dintre incluziunea de clase și moștenirea de clase și când se folosește fiecare metodă.
13. Descrieți pe scurt constructorul de copiere și situațiile în care
acesta este folosit.
14. Descrieți pe scurt ce reprezintă obiectul implicit al unei funcții.
15. Descrieți diferența dintre un pointer și o referință.
16. Descrieți pe scurt cum puteți prelua o dată prin incluziune și a doua
oară prin moștenire o clasă numar într-o clasă lista care descrie liste
nevide de dimensiune variabilă de elemente de tip numar.
17. Descrieți pe scurt metoda de identificare a tipului în timpul rulării
(RTTI).
18. Spuneți dacă o variabilă constantă poate fi transmisă ca parametru al
unei funcții și dacă da, în ce situații. Justificați.
19. Spuneți ce reprezintă o funcție virtuală și în ce condiții o funcție virtuală definește o clasă
abstractă.
20. Spuneți pe scurt prin ce se caracterizează un câmp static al unei clase.
21. Spuneți ce reprezintă o funcție prietenă (friend) a unei clase.
22. Spuneți dacă o variabilă constantă poate fi transmisă ca parametru al unei funcții și dacă
da, în ce situații. Justificați.
23. Descrieți pe scurt ce reprezintă obiectul implicit al unei metode.
24. Descrieți pe scurt ce reguli verifică supraîncărcarea operatorilor.
25. Descrieți pe scurt cum se comportă constructorii de copiere la moștenire.
26. Descrieți pe scurt operatorul typeid.
27. Spuneți ce este obiectul implicit al unei metode și descrieți pe scurt proprietățile pe care le
cunoașteți despre acesta.
28. Descrieți pe scurt functiile virtuale și scopul în care sunt folosite.
29. Descrieți pe scurt funcțiile constante si dați un exemplu de utilizare.
30. Descrieți pe scurt diferența dintre un pointer și o referință.