#include <iostream.h>

typedef int IntArray[2];

typedef struct
{
  int A, B;
} IntStruct;

class TwoClass
{
  protected:
    IntArray A;

  public:
    TwoClass();
    TwoClass(IntArray X);
    void Display();
}

TwoClass::TwoClass()
//Default constructor;
{
}

TwoClass::TwoClass(IntArray X)
//Constructor to allow initialization from integer array
{
  A[0] = X[0];
  A[1] = X[1];
}

void TwoClass::Display()
//Display data members
{
  cout << "A[0] = " << A[0] << "\n";
  cout << "A[1] = " << A[1] << "\n";
}

class OneClass
{
 protected:
   float A, B;                 //two data members

 public:
   OneClass();                 //constructors
   OneClass(IntArray X);
   OneClass(IntStruct Y);
   void Display();
   operator TwoClass();
};

OneClass::OneClass()
//Default constructor
{
}

OneClass::OneClass(IntArray X)
//Constructor to allow conversion from integer arrays
{
  A = X[0];
  B = X[1];
}

OneClass::OneClass(IntStruct Y)
//Constructor to allow conversion from IntStruct variables
{
  A = Y.A;
  B = Y.B;
}

void OneClass::Display()
//Display object data members.
{
  cout << "1st data member = " << A << "\n";
  cout << "2nd data member = " << B << "\n";
}

OneClass::operator TwoClass()
{
  IntArray X;
  X[0] = A;
  X[1] = B;

  TwoClass Y = TwoClass(X);
  return(Y);
}

void main()
{
  IntArray X;     //array of 2 integer elements
  IntStruct Y;    //struct with 2 integer data fields

  X[0] = 1;
  X[1] = 2;
  OneClass I = OneClass(X);   //constructor initialization
  OneClass J = (OneClass) X;  //C style typecast
  OneClass K = X;             //conversion constructor
  I.Display();
  J.Display();
  K.Display();

  Y.A = 3;
  Y.B = 4;
  OneClass L = OneClass(Y);   //constructor initialization
  OneClass M = (OneClass) Y;  //C style typecast
  OneClass N = Y;             //conversion constructor
  L.Display();
  M.Display();
  N.Display();

  Y.A = 5;
  Y.B = 6;
  OneClass W = Y;             //create OneClass instance W
  W.Display();
  TwoClass Q = (TwoClass) W;  //convert W TwoClass instance
  Q.Display();
}