Удвоение оператора присваивания

#include <iostream>
 
class B
  {
protected:  
   int n;
 
public: 
// Constructors
    B() : n(0) {};
    B(int N) : n(N) {};
 
// Destructor
   ~B(){n = 0;} 
 
 
   B & operator=(const B & U)  // copy assign
   {
printf("copy = B -> B\n");
    n = U.n;
    return *this;
   }
   B & operator=(B && U)       // move assign
   {
printf("move = _B -> _B\n");
    n = U.n;
    U.n = 0;
    return *this;
  }
 
//Debug function
   void Display() const
     {
      std::cout << n;
     }
  }; // end of  class B
  
//////////////////  D ///////////
class C: public virtual B
  {
  }; // end of class D
 
 
//////////////////  D ///////////
class D: public virtual B
  {
  }; // end of class D
 
//////////////////  E ///////////
class E: public C, public D
  {
public:
// Constructors
   E(): B(){};
   E(int N): B(N){};
  }; // end of class E
  
  
////////////  main  ///////////  
int main()
  {
   E y(3);
   E z;
   z = std::move(y);
   z.Display();
   return 0;
  }

#include <iostream>
 
class B
  {
protected:  
   int n;
public: 
    B() : n(0) {};
    B(int N) : n(N) {};
 
   ~B(){n = 0;} 
 
   B & operator=(const B & U)  // copy assign
   {
printf("copy = \n");
    n = U.n;
    return *this;
   }
   B & operator=(B && U)       // move assign
   {
printf("move = \n");
    n = U.n;
    U.n = 0;
    return *this;
   }
 
void Display() const
     {
      std::cout << n << "\n";
     }
  }; 
 
class C: public virtual B
  {
  };
 
class D: public virtual B
  {
  }; 
 
class E: public C, public D
  {
public:
   E(): B(){};
   E(int N): B(N){};
  }; 
  
int main()
  {
   E y(3);
   E z;
   z = y;
   z = std::move(y);
   z.Display();
   return 0;
  }