Paul Bibbings wrote:
Since I have used the following in another post, can someone just
confirm (or otherwise) whether the following definition of a
user-defined op= for a type with a reference member is well defined?
class AType
{
public:
AType(int& i)
: i_(i)
{ }
// ...
AType& operator=(const AType& other)
{
if (this != &other)
{
this->~Atype();
new (this) AType(other);
}
return *this;
}
private:
int& i_;
};
According to my reading of the example given in [basic.life] ?3.8/7 I
believe that it is, in this instance (since the constructor doesn't
throw, except on bad_alloc).
It is undefined behavior according to [3.8/7, item 3], which requires:
...
the type of the original object is not const-qualified, and, if a class
type, does not contain any non-static data member whose type is const-
qualified or a reference type,
...
Since AType contains a non-static reference member, the trick does not work
for AType. Note that in the example in the standard, there is no non-static
reference member.
I know: it's a bummer since classes with reference members are about the
only cases, where one might even consider this trickery (which is poor form
anyway).
It is indeed a bummer. I had somehow managed to `parse' 3.8/7
can't. But that leaves me thinking, how /do/ you write a