Benefits of using reference_wrapper instead of raw pointer in containers?

26
votes

What benefits has using std::reference_wrapper as template parameter of containers instead of raw pointers? That is std::vector<std::reference_wrapper<MyClass> > vs. std::vector<MyClass*>

I like forgetting about nulls and not having to use pointer syntax, but the verbosity of the types (i.e. vector<reference_wrapper<MyClass> >) plus having the call site use std::ref to wrap the actual reference makes me think it is not worth it.

I am referring to cases in which using std::shared_ptr or any other smart pointer is not an option.

Are there other benefits of using reference_wrapper or any other factors I am currently not taking into account? (I think my question applies to both C++11's reference_wrapper and boost's)

2
c++stlc++11
IMO, reference non-nullity is a great benefit, that often outweighs the verbosity. But this is just an opinion of a seasoned null-hater. – kkm
@kkm does this argument still hold with not_null pointers? – Rufus
@Woofas: Maybe not. I'm not very familiar with the latest language proposals. This one has been out for the whoppin' 3 days! :) – kkm
"plus having the call site use std::ref to wrap the actual reference" That is not required in contexts where the expected type is known and hence can use std::reference_wrapper<>'s implicit conversion operator to its ::type&. – underscore_d

2 Answers

22
votes

I don't think there is any technical difference. Reference wrapper provides basic pointer functionality, including the ability to change the target dynamically.

One benefit is that it demonstrates intent. It tells people who read the code that "whoever" has the variable, isn't actually controlling its lifespan. The user hasn't forgotten to delete or new anything, which some people may start to look for when they see pointer semantics.

0
votes

C references are really problematic while working with templates. If you are "lucky" enough to compile code with reference as a template parameter you might have problems with code that would work (for some reason) as follows:

template<class T> f(T x) { g(x); }
template<class T> g(T x) { x++; }

Then even if you call f<int&>(x) it will call g<int>. But reference_wrapper works fine with templates.

As also mentioned earlier - you will have problems with compiling things like vector<int&>, but vector<reference_wrapper<int>> works fine.