CPP Technical Exam

What is the output of the code below? 
Assume all necessary header files and namespaces are included.

class state{
 public:
  ~state(){set();}
  void set() { cout << "state ";}
};

class tired : public state{
 public:
  ~tired(){set();}
  void set() { cout << "tired ";}
};

int main(int argc){
 state o1; 
 tired o2;
}

Pick the most suitable option for the code below. Assume inclusion of all necessary headers and namespaces

class BaseClass
{
 private:
  virtual inline void FunOne()
  { 
   cout <<" BaseClass::FunOne "; 
  }
};

class DerivedClass : public BaseClass
{
 public:
  void FunOne()
  {
   cout <<" DerivedClass::FunOne "; 
  }
};

int main()
{
 BaseClass *pObj = new DerivedClass();
 pObj->FunOne();
 delete pObj;
 return 0;
}

What is the output of the code shown below? Assume inclusion of all necessary headers and namespaces

class B {
 public:
  int f(int i) { cout << "int"; return i+1; }
};

class D : public B {
 public:
  double f(double d) { cout << "double"; return d+1.3; }
};

int main(){
 D* pd = new D;

 pd->f(2);
 pd->f(2.3);
}

 In the code below,Which of the following statements will be ill-formed?

struct A{
  explicit A(int x){}
  operator int(){
    int x = 0;
    return x;
  }
};

int main(){
  A a1(2);            // Line 1
  A a2 = 3;          // Line 2
  A a3 = 2.21;     // Line 3
}

The C++ standard states:
"An lvalue of a non-function, non-array type T can be converted to an rvalue…. 
If T is a non-class type, the type of the rvalue is the cv-unqualified version of T. Otherwise, the type of the rvalue is T"

Consider the code below

struct A{
  int x;
  A(int i) : x(i) { }
  operator int(){return x;}
};

int main(){
  int x;
  const int y = 2;
  A a(1);
  const A ac(2);

  x = y;    // Line1
  x = ac;  // Line2
  y = ac;  // Line3
}

Which of the above statements are illegal with reference to the quote from the standard?

Predict the output of the code shown below.

struct A{
 operator int(){cout << "1"; return 0;}
 operator unsigned int(){cout << "2"; return 0;}
};

int main(){
 int x = 2, y = 3;
 unsigned int z = 2;
 x = (x < y) ? A() : y+z;
}

 What is the last digit printed in the output of the code shown below? 
Assume inclusion of all necessary headers and standard namespaces

struct A {
 A(int x = 0) : mx(x)  { }
 A& operator=(int x)  { cout << "1";  mx = x;  return *this; }
 A& operator=(long l)  { cout << "2";  mx = (int)l;  return *this; }
 A& operator=(bool b)  { cout << "3";  mx = b;  return *this; }
 
 int mx;
};

struct B {
 B(long l = 0L) : ml(l)  { }
 operator long()  {  return ml;  }
 long ml;
};

struct C {
 C(bool b = false) : mb(b)  { }
 operator bool()  {  return mb;  }
 bool mb;
};

int main(){
 C c;
 A a;
 B b;
 a = c + b;
}

What is the output of the following program

#include
using namespace std;

class AB{
  public:
    AB(double){}
};

void func(int a, double b)  {cout << 1;}
void func(double a, int b)  {cout << 2;}
void func(AB a, int b)      {cout << 3;}
void func(int ...)          {cout << 4;}
void func(AB ...)           {cout << 5;}

int main(){
  AB c(5.5);

  func(2.0, 2);
  func(c, 2.0);
  func(c, "Hello");

}

Consider the code shown below.

class B {};
class BB : public B{};
class BBB : public BB{};

void f(B *){}
void f(BB *){}
void f(void *){}

int main(){
  B *pb;
  BB* pbb;
  ___ *pbbb;

  f(pb);
  f(pbb);
  f(pbbb);
}

If you are told that the call f(pbbb) calls function "void f(BB *)", 
then which of the following types are applicable to pbbb other than BB*?

What is the output of the code below?
Assume the inclusion of all necessary headers and standard namespaces.

void Fn(const char *a){
  cout << "Fn1 ";
}
template  void Fn(const T a){
  cout << "Fn2 ";
}
int main()
{
  char *str = "Mango";
  char str1[] = "Tree";
  const char *str2 = str1;
  Fn(str);
  Fn(str1);
  Fn(str2);
}

void Fn(const int &x){
  cout << "Fn1" << " ";
}
void Fn(int &x){
  cout << "Fn2" << " ";
}

template  void Fn(const T a){
  cout << "Fn3" << " ";
}
void main(){
  const int nMax = 255;
  int nVar = 100;
  Fn(nMax);
  Fn(nVar);
}

What is your opinion on the code below?

int Fn(int a, int b){
  return a;
}

double Fn(double a, double b){
  return a;
}

template  T Fn(T a, T b){
  return a;
}

void main(){
  double a = 2.0;
  int d = 1;
  double e = Fn(d, a);
}

As responsible class designers, which of the following would you additionally implement in the RollNumbers class shown below with respect to the subscript overloaded operator?

class RollNumbers{
  public:
    RollNumbers(){ members[0] = ""; members[1] = "";}
    string& operator[](const int index){return members[index];}
  private:
    string members[2];
};

For the code shown below, how many functions are part of the candidate function set for the addition statement in the main function?
class mydata{
    int mx;
  public:
    mydata(int x = 0) {mx = x;}
    mydata operator+(const mydata& rhs){
       mydata temp(rhs);
       temp.mx += mx;
       return temp;
    }
   mydata operator+(int x){
      mydata temp(*this);
      temp.mx += x;
      return temp;
   }
   operator int() const{
      return mx;
   }
};

int main(){
  mydata d(3);
  mydata r = d + 5;
}

Which of the following options is correct about the code shown below?

class AClass{
 private:
  AClass(const AClass&rhs){
    mx = rhs.mx;
  }
 public:
  AClass(int x) : mx(x){}
  AClass& operator+=(const AClass& rhs){
    mx += rhs.mx;
    return *this;
  }
  AClass operator+(const AClass& rhs){
    AClass temp(*this);
    temp += rhs;
    return temp;
  }
 private:
  int mx;
};

int main(){
  AClass a(3);
  AClass b(5);
  b = b + a;  // Call 1
  b += a;     //  Call 2
  b + a;       //  Call 3
}

Consider the set of statements given below for a overloaded operator member function of class X. 
Which of the following could be correct?

X ret (*this);
++*this;
return ret;

What is the output of the following program

class CB{
  private:
    int m_nState;
  public:
    CB(int nState = 0): m_nState(nState){cout << 1;}
    CB(const CB& obj){ m_nState = obj.GetState();}
    ~CB(){}
    operator int(){return m_nState;}
    int GetState() const {return m_nState;}
    CB& operator= (const CB& obj){
      m_nState = obj.GetState();
      return *this;
    }
};

int main(void){
  CB obj1 = 2; 
  CB obj2;
  obj2 = obj1 + 3;
}

If the following code has to compile without changing the main function, which of the following options is correct ? 
Assume all header files and standard namespaces are included.

class CA{
  private:
    int m_Var;
  public:
    int GetState() const  {return m_Var;}
    void SetState(int nVar)  {m_Var = nVar;}
    bool operator > (const CA &obj2) {
      return (m_Var > obj2.m_Var) ? true : false;
    }
};

int main(void) {
  CA obj1;
  obj1.SetState(2);
  if(obj1 > 3){cout << "In If block" << endl;}
}