Assignment operator with reference members

Question

Is this a valid way to create an assignment operator with members that are references?

#include <new>

struct A
{
    int &ref;
    A(int &Ref) : ref(Ref) { }
    A(const A &second) : ref(second.ref) { }
    A &operator =(const A &second)
    {
        if(this == &second)
            return *this;
        this->~A();
        new(this) A(second);
        return *this;
    }
}

It seems to compile and run fine, but with c++ tendency to surface undefined behavior when least expected, and all the people that say its impossible, I think there is some gotcha I missed. Did I miss anything?

By the way, the arguments to `operator=` and the copy constructor should be const references. — Christian Rau, Oct 26 '11 at 16:59
Correctness may be limited to standard layout types, since with virtuals `this` need not be a pointer to the beginning of the memory block. — edA-qa mort-ora-y, Oct 26 '11 at 17:02
If you need to do this I'd suggest rethinking using references. — bames53, Oct 26 '11 at 17:04
References can not be reseated. If you need to reseat one, then a reference was not the correct type in the first place. — Dennis Zickefoose, Oct 26 '11 at 17:09

score 46 · Accepted Answer · edited Oct 26 '11 at 17:14

46

It's syntactically correct. If the placement new throws, however, you end up with an object you can't destruct. Not to mention the disaster if someone derives from your class. Just don't do it.

The solution is simple: if the class needs to support assignment, don't use any reference members. I have a lot of classes which take reference arguments, but store them as pointers, just so the class can support assignment. Something like:

struct A
{
    int* myRef;
    A( int& ref ) : myRef( &ref ) {}
    // ...
};

edited Oct 26 '11 at 17:14

Christian Rau

45,360
10
108
185

answered Oct 26 '11 at 17:09

James Kanze

150,581
18
184
329

I like this -- straightforward solution! – aardvarkk Mar 15 '13 at 14:51

score 10 · Answer 2 · answered Mar 15 '16 at 11:29

10

Another solution is to use the reference_wrapper class ( in functional header ) :

struct A
{
    A(int& a) : a_(a) {}
    A(const A& a) : a_(a.a_) {}

    A& operator=(const A& a)
    {
        a_ = a.a_;
        return *this;
    }

    void inc() const
    {
        ++a_;
    }

    std::reference_wrapper<int>a_;

};

answered Mar 15 '16 at 11:29

alangab

849
5
20

With an assignment expression `a = b;` when `a` has type `reference_wrapper`, it seems that if `b` has type (convertible to?) `reference_wrapper`, this will *reseat* `a` to refer to `b`, but if not, and if `b` has type (convertible to?) `T`, the `T` object referenced by `a` will be assigned the value `b`. Is this true? If so, it seems to introduce some subtleties for implementing function templates that perform `a = b;` where we don't know the concrete types, but only that `b`'s type is implicitly convertible to `a`'s. – j_random_hacker Apr 19 '18 at 14:03

score 4 · Answer 3 · answered Oct 26 '11 at 17:00

4

What you do its technically correct as far as I know, but it generates trouble. For instance, consider what happens with a derived class from A, since its assignment operator generates a new object (slicing). Can't you just turn the reference into a pointer within your class?

Besides that, copy constructors and assignment operators usually take its argument by const&.

answered Oct 26 '11 at 17:00

K-ballo

80,396
20
159
169

1

How does this generate trouble? – edA-qa mort-ora-y Oct 26 '11 at 17:01

score 1 · Answer 4 · edited May 23 '17 at 12:06

1

What you do is correct, but it is not very exception safe way of writing an copy assignment operator. Also, You should consider using a pointer member rather than an reference member.

You should implement it using the Copy and Swap Idiom. It has atleast 3 advantages over your implementation.

edited May 23 '17 at 12:06

Community

1
1

answered Oct 26 '11 at 17:01

Alok Save

202,538
53
430
533

1

But then how to swap the references? – Christian Rau Oct 26 '11 at 17:02
@ChristianRau:You would be implementing your own `swap` function anyways. – Alok Save Oct 26 '11 at 17:05
Yes, and this probably needs to swap the references. – Christian Rau Oct 26 '11 at 17:07
2

Specifically, `swap` will require destroying `A` and then calling placement new, just like this does. Copy-and-swap depends on there being a nothrow swap implementation available, and this type does not have one. – Dennis Zickefoose Oct 26 '11 at 17:29
@DennisZickefoose: It saves you the self assignment check. – Alok Save Oct 26 '11 at 17:50

Assignment operator with reference members

4 Answers4

Linked

Related