Use std::reference_wrapper to handle const T& in constructor - appropriate?

Question

A class owns an object of type U. Through a method it exposes this object as a const U& using a getter (not cheaply copyable, modification is not desired).

A client, now, wants to make use of this API. He wishes to use the instance of U as part of a complex object (which has no interest in changing the API object). Therefore, he has at least the following option: Create a class T with const U& as parameter and a private field of type const U&, where the constructor stores the instance of the API. This has the extreme disadvantage of making the instances of the class extremely unflexible (e.g. no management using std::vectors), which is not desired.

Not a long time ago, I found that one also could use a std::reference_wrapper<const U>, to store the const U&, which would not impose those disadvantages on instances of type T.

The question now is, does this behave like it is expected and is it a good practice to do so?

In the following and here, you can find a working code using this strategy and the types described.

#include <iostream>
#include <memory>

class U{
    public: 
    uint value;
};

class T{
private:
    std::reference_wrapper<const U> _u;

public:
    T(const U& u)
        :_u(u) {}

    const U& GetU(){
        return _u;
    }
};

const U& provideValue(U& u){
    return u;
}

int main()
{
    U internalApiValue;
    internalApiValue.value = 5;

    auto apiValue = provideValue(internalApiValue);

    T container(apiValue);

    std::cout << container.GetU().value;
}

I guess if this is not a good idea, the only alternative would be avoiding const, because else I would impose high restrictions on the users of such methods (methods exposing const U& instead of U& or U)?

Answer 1

One major issue with your interface is that T's only constructor takes a const U&. This means you could pass a temporary to T and be left with a reference_wrapper to a dead object since const& in an object does not extend the lifetime of the temporary.

To solve this you need to add a deleted constructor that stops you from accepting temporaries. Adding

T(const U&&) = delete;

will do that.

Answer 2

This should be doing what you want. It's using std::reference_wrapper<T> in the way it was intended to be used (passing around references in a way that makes them copyable and assignable). I don't see anything wrong with it. From cppreference.com:

std::reference_wrapper is a class template that wraps a reference in a copyable, assignable object. It is frequently used as a mechanism to store references inside standard containers (like std::vector) which cannot normally hold references.

The only potential downside I see is that an std::reference_wrapper<T> may be a bit akward to use and unfamiliar to some. A more common solution to your problem would probably be to just store a pointer in your object instead of a reference. For example:

class T {
private:
    const U* _u;

public:
    T(const U& u)
        : _u(&u) {}
    …
};