class A

{
int x,y;
const int z;
public:
A(int x1, int y1, int z1):z(z1)
{
x=x1;
y=y1;
z=z1; //Delete that, but not nessery for compilation
}
};

class B: public A
{

int x;
A* ptr_a;
public:
B(int x1, A& a1):A(0,0,0)
//never mind what should be here
but you should call to the constructor that recive three arguments
OR create default constructor in class A
{
x=x1;
ptr_a = new A(a1);
}
};

class A
{
public:
A()

{cout<<"(1)"<<endl;}

void f()

{cout<<"(2)"<<endl;}

void g()

{cout<<"(3)"<<endl;}

virtual void h()

{cout<<"(4)"<<endl;}

virtual ~A()

{cout<<"(5)"<<endl;}

};

class B : public A
{
A a1;
public:
B()

{cout<<"(6)"<<endl;}

virtual void f(int i)

{cout<<"(7)"<<endl;}

void g()

{cout<<"(8)"<<endl;}

void k()

{cout<<"(9)"<<endl;}

virtual void l()

{ h(); cout<<"(10)"<<endl;}

~B()

{cout<<"(11)"<<endl;}

};

class C : public B
{
A a2;
public:
C()

{cout<<"(12)"<<endl;}

void h()

{g(); cout<<"(13)"<<endl;}

void f()

{cout<<"(14)"<<endl;}

virtual void k()

{cout<<"(15)"<<endl;}

virtual ~C()

{cout<<"(16)"<<endl;}

};

void main()
{
// Part 1:
A* ptr_A = new A;
B* ptr_B = new B;

C* ptr_C = new C;

// Part 2:
ptr_A->g();
ptr_B->g();
ptr_C->g();
//----------------------// Part 3:
A* ptr_AtoC = ptr_C;
ptr_AtoC ->h();
//----------------------// Part 4:
B* ptr_BtoC = dynamic_cast<B*>(ptr_AtoC);
if(ptr_BtoC)
ptr_BtoC->k();
else
ptr_AtoC->f();
//----------------------// Part 5:
delete ptr_A;
delete ptr_B;
delete ptr_C;
}

C::k()
B::l()
B::f(int)
~C()
C::h()
B::l()
B::f(int)
~B()
A::h()
~A()
A::h()
A class VTABLE
B class VTABLE
C class VTABLE

Part 1

//---------// Part 1:

(1)
(1)
(1)
(6)
(1)
(1)
(6)
(1)
(12)
Part 2
(3)
(8)
(8)

//---------// Part 2:

Part 3
(8)
(13)
Part 4
(9)

//---------// Part 3:

Part 5
(5)
(11)
(5)
(5)
(16)
(5)
(11)
(5)
(5)

//---------// Part 4:

PhoneNumber

//
+ const long& PhoneNumber::Something(const int*const pNum) const;
//

(1)

(2)

(3)

ostream & phoneNumber::print(ostream &out)const

{
out<<"("<<m_countryPrefix<<")"<<m_sAreaCode<<"-"<<m_number;
return out;
}
ostream& operator<<(ostream &out, const phoneNumber& p)
{
p.print(out);
return out;
}

(4)

Rational.h

class Rational
{
int nominator;
int denominator;
public:
// Cosntructors
1.
Rational()
2.
Rational(int i_nominator, int i_denominator=1);
3.
Rational(const Rational& other);
// Set and get methods
void set_nominator(int i_nominator);
void set_denominator(int i_denominator);
int get_nominator()const;
int get_denominator()const;

4.
5.
6.
7.
8.
};

// Operators
const Rational operator+ (const Rational& other)const;
const Rational operator+ (const Rational& other);
friend int operator+ (int r1, const Rational& r2);
Rational& operator= (const Rational& other);
operator int() const;

main.cpp
# include "Rational.h"
int main()
{
11.
Rational r1 (1, 2);
12.
Rational r2 (2+r1);
13.
const Rational r3 (1,3);
14.
15.
16.
17.
18.
19.
}

Rational r4 = 1 + r3 + 2;
int x1 = r1 + r3;
Rational r5 = r3 + r2 + r1;
r4 = (int) r1 + (int) r2;
r5 = r3 + (Rational) 3 + r3;
int x3 = (int) r1 + r2;

20.

Rational r6 = r1 + 2;

1.
2.
3.
4.

Rational
Rational
r8 = r1r9 = 2 -

r1(2,3), r2(1,2);
r8, r9;
r2;
r1;

friend const Rational operator- (int r1, const Rational& r2);

const Rational operator- (int r1, const Rational& r2)

{
Rational temp;
temp.set_nominator(r1*r2.denominator - r2.nominator);
temp.set_denominator(r2.denominator);
return temp;
}

A a;
(C(a)).print();

void func1(int a, char b)

{
try
{
if (a == 8)

{
throw a;
throw b;
}
}
catch()
{
cout<<"error";
}
}

class B {};
class D1 : virtual public B {};
class D2 : virtual public B {};
class L : public B{};
class LL : public D1, public D2, public L
{};

1
2
3
4
5
6
7
8

class A{
class C{
int n;
public:
int f();
}; // C
public:
int n;

9
class D{
10
int n;
11
public:
12
int f();
13
private:
14
class B{
15
static int n;
16
}; // B
17
}; // D
18
D::B b;
19
int f();
20 }; // A

int f(){ return A::D::n; }

int A::D::f(){ return (n + B::n); }
int A::D::f(){ return (n + A::n + d.f()); }