Re: user-defined op= for type with reference member

On Jun 13, 1:30 pm, "Leigh Johnston" <le...@i42.co.uk> wrote:

I don't disagree, on the whole, with the conclusions reached in this
thread, but I am having some problem with it being stated in terms of
it
being "UB to reseat a reference." To my mind, "if you call destructor
and placement new in a class's assignment operator" you are *not*
thereby "reseat[ing] a reference." You *are* destructing an object
and
creating a new one in its place, with the attendant UB that has been
identified in the examples given; however, there is, to my mind, no
reference-reseating simply because, with the destruction of the
original
object, it's reference-member is destroyed with it and a *new* one
created in its place.

Now, if you consider the following:

   #include <new>

   class HasRefMem {
   public:
      HasRefMem(int& i)
         : i_(i)
      { }
      HasRefMem& operator=(const HasRefMem& other)
      {
         if (this != &other)
         {
            this->~HasRefMem();
            new (this) HasRefMem(other);
         }
         return *this;
      }
      operator int&() { return i_; }
   private:
      int& i_;
   };

   int main()
   {
      int i, j;
      HasRefMem hrmi(i);
      HasRefMem hrmj(j);
      int& i_ref = hrmi; // #1
      hrmi = hrmj; // #2
   }

then I might be able to consider i_ref (in line #1) as having been
`reseated' in line #2.