This is 20 question and the answers :
***************************************************
***************************************************
1) what is the output of this program?

class base
{
public:
void baseFun(){ cout<<"from base"<<endl;}
};

class dri:public base
{
public:
void baseFun(){ cout<< "from derived"<<endl;}
};

void SomeFunc(base *baseObj)
{
baseObj->baseFun();
}

int main()
{
base baseObject;
SomeFunc(&baseObject);
deri deriObject;
SomeFunc(&deriObject);
}

a) from base
   from base

b) from base
   from derived

c) from derived
   from base

d) undefined


a) this is a static binding

*****************************************************

2) what is the output of this program?

void main()
{
int a=5, *pa, &ra;
pa = &a;
ra = a;
cout <<"a="<<a <<"*pa="<<*pa <<"ra"<<ra ;
}

a) a=5 *pa=5 ra=5
b) a=5 *pa=5 ra=rubbish
c) error
5) a=5 *pa=rubbish ra=5


c)beacuse there is an unintialized reference

*******************************************************
3) what is the output of this program ?

class test
{
public:
~test()
{
cout<<"test distructor"<<endl;
}
};

main()
{
test t;
t.~test();
}


a) error
b) test distructor
c) test distructor
   test distructor


c)we exciplictly call the destructor then it is called automatically

**********************************************************
4)what is the output of this program?

class b
{
public :
  b()
  {
  cout<<"i am b constructor"<<endl;
  }

  ~b()
  {
  cout<<"i am b ditructor"<<endl;
  }

};

 class a
 {
   b x;
 public:
   a()
  {
  cout<<"i am a constructor"<<endl;
  }

  ~a()
  {
  cout<<"i am a ditructor"<<endl;
  }
 };

 class c:a
 {
 public:
  c()
  {
  cout<<"i am c constructor"<<endl;
  }
  ~c()
  {
  cout<<"i am c ditructor"<<endl;
  }
 } ;


 main()
 {
 c a;
 }

a) i am a constructor
   i am b contsructor
   i am c constructor
   i am c destructor
   i am b destructor
   i am a destructor

b) i am b constructor
   i am a constructor
   i am c contsructor
   i am c destructor
   i am a destructor
   i am b destructor

c) i am c constructor
   i am a constructor
   i am b constructor
   i am c destructor
   i am a destructor
   i am b destructor

d) i am a constructor
   i am b contsructor
   i am c constructor
   i am a destructor
   i am b destructor
   i am c destructor


b)

**********************************************************
5) what is the output of this program ?

class test
{
public:
int *ptr;

test(int i)
{
  ptr = new int(i) ;
}

~test()
{
delete ptr;
}
void print()
{
cout<<"value is"<<*ptr<<endl;
}
};

void someFunction(test t)
{
   cout<<"i am some function"<<endl;
}

main()
{
test x(16);
x.print();
someFunction(x);
x.print();
}

a) value is 16 
   in some function
   value is 16

b) value is 16
   in some function
   value is Undefined

c) error


b) we call the function then pass the object for it then after after 
the function is finished 
it call the destructor of the object which will delete the ptr, so the 
value is undefined.

*******************************************************
6) how to define a class as an abstract class?

a) using the keyword abstract before the class name
b) using virtual keyword before the class name
c) using virtual function inside the class definition
d) by declaring a pure virtual function inside the class definition

d)

********************************************************
7) Does the is_a relationship specified in the CRC card ?

a) yes
b) no

b) 

********************************************************
8) what is the output of this program?

class test
{
public :
int a;
};

class test1:protected test
{
public :
int b;
};

main()
{
test t;
t.a=10;
test1 t1;
t1.a=20;
cout<<t.a<<t1.a;
}

a) 1020
b) 1010
c) 2020
d) error

d) protected means that the int a is inherited as protected and can't 
be accessed from thr main function.

***********************************************************
9) what does this piece of code means

class a
{
int x,y;
friend class b;
public:
a()
{
x=0;
y=0;
}
};

class b
{
int z;
public:
b()
{
z=0;
}
};

a) any function in class a can access private members of class b
b) any function in class b can access private members of class a 
c) class b have all private members of class a 
d) class a have all private members of class b

b)

************************************************************
10)can you overload the destructor?

a)yes 
b)no 

b) there us just one destructor per class 

************************************************************
11) what is the output of this program ?

class test
{
int a;
public: 
test()
{
cout<<"i am test constructor"<<endl;
}
~test()
{
cout<<"i am test destructor"<<endl;
}
};

main()
{
test t
test *t1 = new test;
}

a) i am test constructor
   i am test constructor
   i am test destructor

b) i am test constructor
   i am test contsructor
   i am test destructor
   i am test destructor

c) i am test constructor
   i am test destructor

d) i am test constructor
   i am test destructor
   i am test destructor

a)

********************************************************
12)what is the output of this program ?

class test
{
int x,y;
friend class test1 ;
};

class test1: protected test
{
int c,d ;
public:

void function(test t)
{
t.x=204;                         
cout<<t.x;
}
};

void main()
{
test t;
test1 t1;
t1.function(t);
}

a) error
b) undefined value
c) 204

c) although test1 can inherit x,y because they are private but it can 
access them because it is a friend class

********************************************************
13)what is the syntax for passing values to the base class
from a derived class construcor?

a)derived_class_name(arguments)
  {
  base_class_name(list of values);
  }

b)derived_class_name(arguments)::base_class_name(list of values)
{
}

c)derived_class_name(arguments):base_class_name(list of values)
{
}

d)none of the above

c)

***********************************************************
14)is this code is valid for swapping  two values?

main()
{
int x=10;
int y=20;

int &rx=x;
int &ry=y;

swap(&rx,&ry);
}

void swap(int *px,int *py)
{
int temp;
temp=*px;
*px=*py;
*py=temp;
}

a) yes
b) no

a)

**************************************************************
15)what is the output of this program ?

class A
{
int a;
public: 
virtual void function()
{
cout<<"i am from A"<<endl;
}

};

class B : public A
{
int b;
void function()
{
cout<<"i am from B"<<endl;
}
};

class C : public B
{
int c;
void function()
{
cout<<"i am from C"<<endl;
}
};
 
main()
{
A *x=new C;
x->function(); 
}

a) i am from A
b) i am from B
c) i am from C
d) error

c)dynamic binding

*****************************************************************
16)can we have virtual destructors?

a)yes
b)no

a)

*****************************************************************
17)choose the right signature of the copy constructor?

a) className(className objectName)
b) void className(className classObject)
c) className(className& objectName)
d) className(&className objectName)

c)

*****************************************************************
18)what is the output of this program?

class base
{
public :
out()
{
cout<<"base ";
}
};

class deri
{
public : out()
{
cout<<"deri ";
}
};

void main()
{ deri dp[3];
base *bp = (base*)dp;
for (int i=0; i<3;i++)
(bp++)->out();
}

a) base base base
b) deri deri deri
c) error

a)

********************************************************************
19)can we have a static overloaded operator?

a) yes
b) no

b)

********************************************************************
20)what is the output of this program ?

main()
{
int x=19;
const &rx=x;
x=203;
cout<<x<<"-"<<rx<<endl;
}

a) error
b) 203-19
c) 203-203

c)