// temp4.cpp

#include <iostream>

class Y1
{
public:
  Y1() { std::cout << "\n  Y1() called"; }
  Y1(const Y1& y) { std::cout << "\n  Y1(const &Y1) called"; }
  ~Y1() { std::cout << "\n  ~Y1() called"; }
  Y1& operator=(const Y1& y) 
  { 
    if(this == &y) return *this;
    std::cout << "\n  Y1::operator=(const Y1&) called"; 
    return *this;
  }
};

class X1 : public Y1
{
public:
  X1() { std::cout << "\n  X1() called"; }
  X1(const X1& x) : Y1(x) { std::cout << "\n  X1(const &X1) called"; }
  X1(double d) : _d(d) { std::cout << "\n  X1(double d) called"; }
  ~X1() { std::cout << "\n  ~X1() called"; }
  double& myfun() { std::cout << "\n  double& myfun() called"; return _d; }
  X1& operator=(const X1& x)
  {
    if(this == &x) return *this;
    std:: cout << "\n  X1::operator=(const X1&) called";
    (Y1&)(*this) = x;
    return *this;
  }
private:
  double _d;
};

class Y2
{
public:
  Y2() { std::cout << "\n  Y2() called"; }
  Y2(const Y2& y) { std::cout << "\n  Y2(const &Y2) called"; }
  ~Y2() { std::cout << "\n  ~Y2() called"; }
  Y2& operator=(const Y2& y) 
  { 
    if(this == &y) return *this;
    std::cout << "\n  Y2::operator=(const Y2&) called"; 
    return *this;
  }
};

class X2 : public Y2
{
public:
  X2() { std::cout << "\n  X2() called"; }
  X2(const X2& x) : Y2(x) { std::cout << "\n  X2(const &X2) called"; }
  X2(double d) : _d(d) { std::cout << "\n  X2(double d) called"; }
  ~X2() { std::cout << "\n  ~X2() called"; }
  X2& myfun() { std::cout << "\n  double& myfun() called"; return *this; }
  X2& operator=(const X2& x)
  {
    if(this == &x) return *this;
    std:: cout << "\n  X2::operator=(const X2&) called";
    (Y2&)(*this) = x;
    return *this;
  }
private:
  double _d;
};

class Y3
{
public:
  Y3() { std::cout << "\n  Y2() called"; }
  Y3(const Y3& y) { std::cout << "\n  Y3(const &Y3) called"; }
  ~Y3() { std::cout << "\n  ~Y3() called"; }
  Y3& operator=(const Y3& y) 
  { 
    if(this == &y) return *this;
    std::cout << "\n  Y3::operator=(const Y3&) called"; 
    return *this;
  }
  Y3& operator=(double d) 
  { 
    std::cout << "\n  Y3::operator=(double) called"; 
    return *this;
  }
};

class X3 : public Y3
{
public:
  X3() { std::cout << "\n  X3() called"; }
  X3(const X3& x) : Y3(x) { std::cout << "\n  X3(const &X3) called"; }
  ~X3() { std::cout << "\n  ~X3() called"; }
  X3& myfun() { std::cout << "\n  double& myfun() called"; return *this; }
  X3& operator=(const X3& x)
  {
    if(this == &x) return *this;
    std:: cout << "\n  X3::operator=(const X3&) called";
    (Y3&)(*this) = x;
    return *this;
  }
  X3& operator=(double d)
  {
    std:: cout << "\n  X3::operator=(double) called";
    (Y3&)(*this) = d;
    return *this;
  }
private:
  double _d;
};

class LastToCall
{
public:
  ~LastToCall()
  {
    std::cout << "\n\n";
  }
} ltc;  // a global resulting in a couple of newlines at end of program.

void main()
{
  std::cout << "\n  Midterm #3 - Question #4"
            << "\n ==========================\n";

  std::cout << "\n  case #1 - myfun() returns double&"
            << "\n -----------------------------------\n";

  X1 x1 = X1().myfun() = 3.1415927;

  std::cout << "\n\n";
  std::cout << "\n  case #2 - myfun() returns X&, X has X(double)"
            << "\n -----------------------------------------------\n";

  X2 x2 = X2().myfun() = 3.1415927;

  std::cout << "\n\n";
  std::cout << "\n  case #3 - myfun() returns X&, X has operator=(double)"
            << "\n -------------------------------------------------------\n";

  X3 x3 = X3().myfun() = 3.1415927;

  std::cout << "\n\n";
}