1
Q
int returnByValue()
{
return 5;
}
int& returnByReference()
{
static int x{ 5 };
return x;
}
int main()
{
int value{ returnByReference() };
int &ref{ returnByValue() };
const int &cref{ returnByValue() }; return 0; }
A
-static ensures x isn’t destroyed when the function ends
case A – ok, treated as return by value
case B – compile error since the value is an r-value, and an r-value can’t bind to a non-const reference
case C – ok, the lifetime of the return value is extended to the lifetime of cref
2
Q
const int& returnByReference()
{
return 5;
}
int main()
{
const int &ref { returnByReference() };
}
A
runtime error
3
Q
const int returnByValue()
{
return 5;
}
int main()
{
const int &ref { returnByValue() };
}
A
ok, we’re extending the lifetime of the copy passed back to main
4
Q
string get_name()
{
string s="magic";
return s;
}
int main()
{
string p=get_name();
std::cout<<p></p>
A
ok
5
Q
#include
using namespace std;
string get_name()
{
string s="magic";
return s;
}
int main()
{
string& p=get_name();
std::cout<<p></p>
A
//nu compileaza //nu ai voie sa faci bind unei referinte de o valoare temporara
6
Q
#include
using namespace std;
const string& get_name()
{
string s="magic";
return s;
}
int main()
{
string& p=get_name();
std::cout<<p></p>
A
nu compileaza, s-a scapat ilegal de const
7
Q
#include
using namespace std;
string get_name()
{
string s="magic";
return s;
}
int main()
{
const string& p=get_name();
std::cout<<p></p>
A
/functioneaza, iar valoarea temporara va fi distrusa atunci cand va iesi referinta din scop
8
Q
#include
using namespace std;
const string& get_name()
{
string s="magic";
return s;
}
int main()
{
const string& p=get_name();
std::cout
A
runtime error, se mosteneste durata de viata a valorii trimise prin const reference si era o variabila locala deci a murit
9
Q
#include
using namespace std;
string o= "opapa";
const string& get_name()
{
string s="magic";
return o;
}
int main()
{
const string& p=get_name();
std::cout<
A
opapa
10
Q
Ce e aia lifetime extension? cand functioneaza si cand nu functioneaza?
A
Functioneaza atunci cand un local const T& sau T&& este initializat din reziltatul unei expresii care returneaza:
-un temporar T
-T subobiectul unui temporar(un struct care contine T)
In cazul acesta, obiectul T este distrus atucni cand referinta iese din scop.
Cand nu merge lifetime extension?
-cand facem assignment la T& nu const T& - eroare de compilare
-cand se face non-polimorfic type conversion. type-conversion e permisa atunci cand faci assignment la T& dintr-un temporar U , unde U este copil al lui T
11
Q
Compileaza sau nu? Daca da de ce, daca nu de ce?
#include
using namespace std;
struct Person {
struct Name {
std::string first_name;
std::string last_name;
} name;
};
Person birth;
int main()
{
const std::string &first_name = birth.name.first_name;
}
A
Merge, si birth este distrus dupa ultima acolada.
12
Q
Spuneţi de câte ori se execută fiecare constructor în programul de mai jos şi în ce ordine.
#include
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<
A
eroare: - nu exista
- lipseste namespace std si avem cout
- daca nu ar lipsi s-ar afisa 28
- se apeleaza cls1(), cls2(), cls1(ob), cls2(ob)
13
Q
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
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;
std::cout<
A
- nu exista
- lipseste namespace std si avem cout
se afiseaza 14
static in funtie face sa nu se distruga obiectul la iesirea din functie
14
Q
#include
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);
std::cout<
A
- nu exista
- lipseste namespace std si avem cout
-nu exista clasa cls
- daca acolo ar fi cls1 s-ar afisa 37
- daca acolo ar fi cls2 ar fi eraore(mostenirea e automat privata)
15
Q
Ruleaza sau nu? Daca da, de ce, daca nu, de ce? #include
class Money
{
public:
Money() : amount{ 0.0 } {};
Money(double _amount) : amount{ _amount } {};
explicit operator double() const { return amount; } private:
double amount; };void display_balance(const Money balance)
{
std::cout << "The balance is: " << balance << std::endl;
}
A
Nu ruleaza pentru ca explicit la conversion opeartor previne conversia implicita catre tipul catre care se converteste.
16
Q
Ruleaza sau nu? Daca da, de ce, daca nu, de ce? #include
class Money
{
public:
Money() : amount{ 0.0 } {};
Money(double _amount) : amount{ _amount } {};
double operator double() const { return amount; } private:
double amount; };void display_balance(const Money balance)
{
std::cout << "The balance is: " << balance << std::endl;
}
A
Nu ruleaza pentru ca e ilegal sa pui return type la conversion function.
17
Q
Ruleaza sau nu? Daca da, de ce, daca nu, de ce? #include
class Money
{
public:
Money() : amount{ 0.0 } {};
Money(double _amount) : amount{ _amount } {};
operator double(double x) const { return amount+x; }
private:
double amount;
};
void display_balance(const Money balance)
{
std::cout << "The balance is: " << balance << std::endl;
}
A
Nu ruleaza pentru ca e ilegal sa pui parametri ca conversion operator.
18
Q
#include
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<
A
Eroare: operatorul * poate primi 0 sau 1 argument.
19
Q
Spuneţi de câte ori este moştenită clasa B în clasa M1. Dar în clasa M2 ? Justificaţi.
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 */ };
A
Pentru M1: de 3 ori :B() D5() D1() D2() B() D3() B() D4() M1()
Pentru M2: de 3 ori B() B() D3() B() D4() D5() D1() D2() M2()
20
Q
#include
using namespace std;
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<
A
doar pentru z e corect
21
Q
#include
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;
std::cout<
A
compileaza, dar nu se afiseaza nimic pentru ca returnez adresa unui int
22
Q
#include
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);
std::cout<
A
2030
23
Q
#include
class cls
{
int x;
public:
cls(int i=25)
{
x=i;
}
int f();
};
int cls::f()
{
return x;
}
int main()
{
const cls d(15);
std::cout<
A
passing ‘const cls’ as ‘this’ argument discards qualifiers – ar trebui ca functia sa fie const si atunci s-ar afisa 15
24
Q
#include
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;
}
A
compileaza
25
```
#include
template
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;
std::cout<
```
afiseaza 1
26
```
#include
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();
std::cout<
```
compileaza si afiseaza 1330860892
27
```
#include
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;
std::cout<
```
6
concluzie: nu trebuie neaparat sa apelezi constructorii bazelor ca sa compileze
28
```
#include
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);
std::cout<
```
nu compileaza
- nu exista constructor cu un singur parametru
- imp nu are specificatorul cls::
- imp este functe const si modifica campurile
- y este const
29
```
#include
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);
std::cout<
```
-89
30
```
#include
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()
{
std::cout
nu compileaza
x e protected
- daca il fac pe x public afiseaza -26
- pot sa fac si un getter doar ca dupa tot o sa fie constructorul lui B protected deci trebuie sa il fac pe el public
31
```
#include
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);
std::cout<
```
37
32
```
#include
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()
{
std::coutminus();
p1->afisare();
return 0;
}
```
-100
33
```
#include
template
class cls
{
tip z;
public:
cls(tip i)
{
z=i;
}
tip operator-(cls);
};
template
tip cls::operator-(cls a)
{
return z-a.z;
}
template
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 i=3;
cls j=4;
std::cout<
```
nu compileaza
-nu e nicio functie dif cu 2 tipuri diferite
-int dif(int x, int y)
{
return x>=y?x-y:y-x;
} nu o sa funtioneze pentru ca eu apelez dif(cls, cls)
ce schimb ca sa functioneze?
34
```
#include
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);
std::cout<
```
15
35
```
#include
class cls
{
int v,nr;
public:
cls(int i)
{
nr=i;
v=new int[i];
}
friend int& operator[](int);
friend std::ostream& operator<
```
nu compileaza
- operator[] must be a nonstatic member funtion => nu poate fi friend
- invalid conversion from int* to int =>trebuie ca v sa fie int*
```
-definitia operatorului din afara clasei nu are specificatori si nu are acceasi signatura cu cea dinauntrul clasei => varianta corecta ar fi :
int& cls::operator[](int i)
{
return v[i];
}
```
acum programul rulezaza si afiseaza
13046584 13041856 0 0 83886085 7 13046584 13041856 0 0
36
```
#include
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;
std::cout<
```
compileaza, afiseaza 12
concluzie: static int si daca nu e initializat se initializeaza automat cu 0
37
```
#include
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);
std::cout<
```
nu compileaza
- se incearca modificarea campurilor dintr-o functie const
- main trebuie sa returneze int
```
daca sterg modific f:
int cls::f() const
{
return x;
}
si schimb void in int la main afiseaza -15
```
38
```
#include
float f(float f)
{
if (f)
throw f;
return f/2;
}
int main()
{
int x;
try
{
std::cout<>x;
if (x)
f(x);
else
throw x;
std::cout<
```
-daca numarul citit de la tastatura este 0 o sa se afiseze "Numarul 0 nu e bun!"
-daca numarul citit este diferit de 0 o sa se arunce float care nu e prins si o sa se afiseze
terminate called after throwing an instance of 'float'
39
```
in ce ordine sunt aplelati constructorii:
#include
class cls1
{
protected:
int x;
public:
cls1()
{
std::cout
```
cls1()cls2()cls3()cls1(ob)cls2(ob)cls3(ob)
40
```
#include
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();
std::cout<
```
compileaza si afiseaza 23 + valoare nedeterminata
de ce? pentru ca new apeleaza si constructorul de la cls, in timp ce cast-ul la cls* de la malloc nu apeleaza constructorul
41
```
#include
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);
std::cout<
```
eroare: constructorul lui B e privat
| - daca fac constructorul si getterul publice o sa afiseze -89
42
```
#include
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;
std::cout<
```
77
43
```
#include
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);
std::cout<
```
47
44
```
#include
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;
std::cout<
```
compileaza si afiseaza 15, adica valoarea pe care i-a dat-o constructorul ultimei baze
daca mostenirea se facea in ordinea class C: public D1, public D2 atunci s-ar fi afisar 37
45
```
#include
#include
using namespace std;
class A{
public:
void afis()
{
cout< (x);
b1->afis();
```
}
se afiseaza aici
46
```
#include
template
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
tip dif(tip x, tip y)
{
return x-y;
}
int dif(cls x, cls y)
{
return x>=y?x-y:y-x;
}
int main()
{
cls i=3;
cls j=4;
std::cout<
```
nu compileaza
| cum repar? pune intrebare pe stackoverflow
47
```
class cls
{
int x;
public:
cls(int i=0)
{
x=i;
}
cls(cls& ob)
{
x=ob.x;
}
};
cls& f(cls &c)
{
return c;
}
int main()
{
cls r;
cls s=r;
f(f(f(s)));
}
```
ruleaza si nu afiseaza nimic
48
```
#include
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;
std::cout<
```
12
49
```
#include
class cls
{
int x;
public:
cls(int i=32)
{
x=i;
}
int f() const
{
return x++;
}
};
void main()
{
const cls d(-15);
std::cout<
```
nu compileaza, se incerca modificarea unui obiect const
50
```
#include
float f(int y)
{
try
{
if (y%2)
throw y/2;
}
catch (int i)
{
if (i%2)
throw;
std::cout<>x;
if (x)
f(x);
std::cout<
```
Numarul 3 e bun!
51
```
#include
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
```
nu compileaza: am const D& a si se apeleaza a[i] iar supraincarcarea operatorului [] nu e const => se trimite un this constant la o metoda neconstanta
daca fac supraincarcarea operatorului [] const atunci se afiseaza 11111
52
```
#include
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);
std::cout<
```
nu compileaza pentru ca x este private, nu protected
daca era protected se afisa -5
as putea si sa inlocuiesc return x+a.x; cu x+a.get_x(); doar ca trebuie sa fac getterul const ca asa trimit un obiect const la o functie neconst
53
```
#include
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()
{
std::cout
41
54
```
#include
class cls
{
int *v,nr;
public:
cls(int i)
{
nr=i;
v=new int[i];
for (int j=1; j
```
garbege000-1500000
55
```
#include
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()++;
std::cout<
```
eroare: incerc sa modific o valoare constanta const int&
daca sterg const-ul de la f compileaza si afiseaza 14
56
```
#include
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;
std::cout<
```
nu compileaza pentru ca x este private si nu am acces la el din D
daca pun protected la inceputul lui B atunci afiseaza 221
57
```
#include
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;
std::cout<<27+a;
return 0;
}
```
11
58
```
#include
class cls
{
static int x;
public:
cls (int i=1)
{
x=i;
}
cls f()
{
return x;
}
static int g()
{
return f()/2;
}
};
int cls::x=7;
int main()
{
cls ob;
std::cout<
```
nu compileaza, nu pot sa apelez functia f fara obiect
```
merge adca o scriu:
static int f()
{
return x;
}
```
59
```
#include
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;
std::cout<
```
```
nu compileaza
daca inlocuiesc functia f cu
static int f()
{
return x;
}
functioneaza
```
60
```
#include
class cls
{
int *v,nr;
public:
cls(int i=0)
{
nr=i;
v=new int[i];
for (int j=0; j
```
afiseaza 8693064 8654400 12 -30 24 30 -30 42 48 54
| intreaba pe stack overflow
61
```
#include
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*")
std::cout
eroare: trebuie sa include
daca includ typeinfo nu afiseaza nimic, dar ruleaza
62
```
#include
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++)
std::cout<
```
eroare: nu am constructor fara parametri
daca pun valoare implicita la constructor imi da eraore ca nu gaseste get_x(int)
=> tai i de la get_x() si atunci functioneaza
afiseaza 0123456789
63
```
#include
template
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;
std::cout<
```
-3
64
```
#include
class cls
{
int *v,nr;
public:
cls(int i)
{
nr=i;
v=new int[i];
for (int j=1; j
```
x[4] si not an lvalue
rezolvare: int& operator[](int i)
65
```
#include
using namespace std;
class B
{
int i;
public:
B()
{
i=50;
}
virtual int get_i()
{
return i;
}
};
class D: public B
{
int j;
public:
D()
{
j=47;
}
int get_j()
{
return j;
}
};
int main()
{
D *p=new B;
cout
pointer la clasa derivata instantiat cu pointer din clasa de baza
daca modific: D *p=new D; sau B *p=new B; sau B *p=new D; compileaza
ce afiseaza in fiecare caz?
1) 5047
2) 50 si valoare nedeterminata
3) 5047
66
```
#include
using namespace std;
template
int functie(X x, X y)
{
return x+y;
}
int functie(int x, int *y)
{
return x-*y;
}
int main()
{
int a=27, *b=new int(45);
cout<
```
-18
67
```
#include
using namespace std;
class A
{
protected:
static int x;
private:
int y;
public:
A(int i)
{
x=i;
y=-i+3;
}
int put_x(A a)
{
return x+a.y;
}
};
int A::x=5;
int main()
{
A a(10);
cout<
```
3
68
```
#include
using namespace std;
class A
{
int i;
public:
A(int x=3):i(x) {}
virtual int get_i()
{
return i;
}
};
class B: public A
{
int j;
public:
B(int x=10):j(x) {}
virtual int get_j()
{
return A::get_i()+j;
}
};
int main()
{
A o1(5);
B o2;
cout<
```
5133
69
```
#include
using namespace std;
class B
{
protected:
int i;
public:
B(int j=5)
{
cout << " cb ";
i=j-2;
}
~B()
{
cout << " db ";
}
int get_i()
{
return i;
}
};
```
```
class D1: public B
{
int j;
public:
D1(int k=10)
{
cout << " cd1 ";
j=i-k+3;
}
~D1()
{
cout << " dd1 ";
}
};
```
```
class D2: public D1
{
int k;
public:
D2(int l=15)
{
cout << " cd2 ";
k=i+j-l+3;
}
~D2()
{
cout << " dd2 ";
}
};
D1 f(D1 d1, D2 d2)
{
return d1.get_i()+d2.get_i();
}
int main()
{
D2 ob2;
D1 ob1(3);
cout<
```
eroare: j e privat si e folosit in D2
daca il fac pe j protected o sa se afiseze:
cb cd1 cd2 cb cd1 cb cd1 6 dd1 db dd1 db dd2 dd1 db dd1 db dd2 dd1 db
70
```
#include
using namespace std;
class B
{
protected:
int i;
public:
B(int j=5)
{
cout << " cb ";
i=j-2;
}
~B()
{
cout << " db ";
}
int get_i()
{
return i;
}
};
```
```
class D1: public B
{
protected:
int j;
public:
D1(int k=10)
{
cout << " cd1 ";
j=i-k+3;
}
~D1()
{
cout << " dd1 ";
}
};
```
```
class D2: public D1
{
int k;
public:
D2(int l=15)
{
cout << " cd2 ";
k=i+j-l+3;
}
~D2()
{
cout << " dd2 ";
}
};
D1 f(D1 d1, D2 d2)
{
return d1.get_i()+d2.get_i();
}
int main()
{
D2 ob2;
D1 ob1(3);
cout<
```
cb cd1 cd2 cb cd1 cb cd1 6 dd1 db dd1 db dd2 dd1 db dd1 db dd2 dd1 db
hai sa o luam pe rand:
cb cd1 cd2 -crearea lui ob2
cb cd1 -crearea lui ob1
cb cd1 -crearea obiectului temporar returnat de f : D(6)
6 - f(ob1,ob2).get_i()+ob2.get_i();
dd1 db -distrugerea obiectului temporar returnat de f
dd1 db -distrugerea copiei lui ob1 cu care se lucreaza in f : d1
dd2 dd1 db -distrugerea copiei lui ob2 cu care se lucreaza in f : d2
dd1 db -distrugerea lui ob1
dd2 dd1 db - distrugerea lui ob2
71
```
#include
using namespace std;
class B
{
protected:
int i;
public:
B(int j=5)
{
cout << " cb ";
i=j-2;
}
~B()
{
cout << " db ";
}
int get_i()
{
return i;
}
};
```
```
class D1: public B
{
protected:
int j;
public:
D1(int k=10)
{
cout << " cd1 ";
j=i-k+3;
}
~D1()
{
cout << " dd1 ";
}
};
```
```
class D2: public D1
{
int k;
public:
D2(int l=15)
{
cout << " cd2 ";
k=i+j-l+3;
}
~D2()
{
cout << " dd2 ";
}
};
D1 f(D1& d1, D2& d2)
{
return d1.get_i()+d2.get_i();
}
int main()
{
D2 ob2;
D1 ob1(3);
cout<
```
cb cd1 cd2 cb cd1 cb cd1 6 dd1 db dd1 db dd2 dd1 db
72
```
#include
using namespace std;
class B
{
protected:
int x;
public:
B(int i=3)
{
x=i;
}
virtual B f(B ob)
{
return x+ob.x;
}
void afisare()
{
coutafisare();
return 0;
}
```
se afiseaza 9
pentru constructia obiectului 3 se apeleaza f din B pentru ca pot sa fac usor upcasting dar nu downcasting
73
```
#include
using namespace std;
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];
for(int i=3; i<9; i++)
p[i].set_x(i);
for(int i=0; i<4; i++)
cout<
```
nu compeleaza pentru ca nu am constructor fara parametri
daca pun cls(int i=0) se afiseaza 0003
74
```
#include
using namespace std;
struct X { int i;
public: X(int ii ) { i = ii; };
int f1() const { return i; }
X f2() const { int i=this->f1(); return X(74-i); }};
const X f3() { return X(8); }
int f4(const X& x) { return x.f1(); }
int main() { X ob(19);
cout<
```
se afiseaza 55
75
```
#include
using namespace std;
class A
{ protected: int x;
public: A(int i):x(i){}
int get_x(){ return x; } };
class B: private A
{ protected: int y;
public: B(int i,int j):y(i),A(j){}
int get_y(){ return get_x()+y; } };
class C: private B
{ protected: int z;
public: C(int i,int j,int k):z(i),B(j,k){}
int get_z(){ return get_x()+get_y()+z; } };
int main()
{ C c(1,2,3);
cout<
```
nu ruleaza
C(int i,int j,int k):z(i),B(j,k){} linia asta functioneaza bine pentru ca C are acces la B si B(int i,int j):y(i),A(j){} B are acces la A
in schimb cand ajunge la
```
int get_z(){ return get_x()+get_y()+z; }
A nu este o baza accesibila a lui C
```
rezolvare: fac mostenirea lui A in B publica si se afiseaza 9
76
```
#include
using namespace std;
class A
{ static int *x;
public: A() {}
int get_x() { return (++(*x))++; } };
int *A::x(new int(10));
int main()
{ A *p=new A,b;
cout
11 13
77
```
#include
using namespace std;
class X { int i;
public: X(int ii = 5) { i = ii; cout<< i<< " ";};
const int tipareste(int j) { cout<tipareste(7);
return 0;
}
```
nu compileaza pentru ca se trimite un obiect constant ca this unei metode neconstante
rezolvare: fac metoda tipareste constanta si atunci se afiseaza 7 7 7 14
78
```
#include
using namespace std;
class X {public: int i;
public: X(int ii = 5) { i = ii; cout<< i<< " ";};
const int tipareste(int j) const { cout<
```
se afiseaza 3
observam ca daca am initializa X O2=O s-ar afisa 7
dar fiindca initializam X& O2=O O2 este practic un alt nume pentru valoarea de la adresa accea de memorie
79
```
#include
using namespace std;
class A
{ int i;
public: A(int x=2):i(x+1) {}
virtual int get_i() { return i; }};
class B: public A
{ int j;
public: B(int x=20):j(x-2) {}
virtual int get_j() {return A::get_i()+j; }};
int main()
{ A o1(5);
B o2;
cout<
```
6 21 3
80
```
#include
using namespace std;
class A
{ protected: static int x;
private: int y;
public: A(int i) { x=i; y=-i+4; }
int put_x(A a) { return a.x+a.y; } };
int A::x=7;
int main()
{ A a(10);
cout<
```
4
81
```
#include
using namespace std;
template
int functie(X x, X y)
{ return x+y;
}
int functie(int & x, int *y)
{ return x-*y;
}
int main()
{ int a=7, *b=new int(4);
cout<
```
3
82
```
#include
using namespace std;
class B
{ int i;
public: B() { i=80; }
virtual int get_i() { return i; }
};
class D: public B
{ int j;
public: D() { j=27; }
int get_j() {return j; }
};
int main()
{ D *p=new B;
cout
nu compileaza pentru ca am downcasting, retin obiect de tip B in D*
pot sa fac B*= new B => 80 gibberish
pot sa fac D*= new D => 8027
pot sa fac B*= new D => 8027
83
```
#include
using namespace std;
class B
{ protected: int i;
public: B(int j=5) {cout << " cb "; i=j-2; }
~B(){ cout << " db ";}
int get_i() { return i; } };
```
```
class D1: public B
{ int j;
public: D1(int k=10) {cout << " cd1 "; j=i-k+3; }
~D1(){ cout << " dd1 ";} };
```
```
class D2: public D1
{ int k;
public: D2(int l=15) {cout << " cd2 "; k=i-l+3; }
~D2(){ cout << " dd2 ";} };
D1 f(D1 d1, D2 d2) {return d1.get_i()+d2.get_i(); }
int main()
{ D2 ob2; D1 ob1(3);
cout<
```
cb cd1 cd2 cb cd1 cb cd1 6 dd1 db dd1 db dd2 dd1 db dd1 db dd2 dd1 db
84
```
#include
using namespace std;
class A
{ static int *x;
public: A() {}
int get_x() { return (++(*x))++; } };
int *A::x(new int(19));
int main()
{ A *p=new A,b;
cout
20 22
85
```
#include
using namespace std;
class X { int i;
public: X(int ii = 5) { i = ii; cout<< i<< " ";};
const int tipareste(int j) const { cout<tipareste(7);
return 0;
}
```
7 7 7 7 14
86
```
#include
using namespace std;
class A
{ protected: int x;
public: A(int i):x(i){}
int get_x(){ return x; } };
class B: A
{ protected: int y;
public: B(int i,int j):y(i),A(j){}
int get_y(){ return get_x()+y; } };
class C: protected B
{ protected: int z;
public: C(int i,int j,int k):z(i),B(j,k){}
int get_z(){ return get_x()+get_y()+z; } };
int main()
{ C c(5,6,7);
cout<
```
nu compileaza: get_x() nu e accessible din C
modificare: fac mostenirea din A in B publica
observatie: constructorii sunt accesibili din lista de initializare la orice adancime, dar restul functiilor nu
87
```
#include
using namespace std;
class cls
{ int x;
public: cls(int i=2) { 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[15];
for(int i=2;i<8;i++) p[i].set_x(i);
for(int i=1;i<6;i++) cout<
```
22345
88
```
#include
using namespace std;
struct X { int i;
public: X(int ii ) { i = ii; };
int f1() { return i; }
X f2() const { int i=this->f1(); return X(34-i); }};
const X f3() { return X(16); }
int f4(const X& x) { return x.f1(); }
int main() {X ob(11);
cout<
```
nu compileaza pentru ca f1 nu e const
avem 2 locuri in care apare aceasta eroare:
1. la X f2() const { int i=this->f1(); return X(34-i); }}; cand this e const si e apelat pe el functia f1
2. la int f4(const X& x) { return x.f1(); } cand am obiectul constant X si apelez pe el f1
daca fac f1 sa fie const afiseaza 23
89
```
#include
using namespace std;
class A
{ protected: static int x;
public: A(int i=1) {x=i; }
int get_x() { return x; }
int& set_x(int i) { int y=x; x=i; return y;}
A operator=(A a1) { set_x(a1.get_x()); return a1;}
} a(33);
int main()
{ A a(18), b(7);
cout<
```
nu compileaza pentru ca nu am initializat staticul x
daca adaug
int A::x=0; o sa compileze si nu o sa afiseze nimic pentru ca incerc sa afisez adresa unei valori temporare
daca set_x ar returna int ar afisa 7
-
Key Links
-
Subjects
-
Company
-
Find Us
-
