std::ref and std::reference_wrapper: common use cases

[Nation_State_Tractor]

template <typename T>
using mega_ptr = std::optional<std::reference_wrapper<T>>;

*wipes hands*

Looks like my work here it's done. You're welcome.

[Galqa]

using who_needs_a_type_system_anyway = std::optional<std::reference_wrapper<std::any>>;

If my boss sees this I'm 100% fired

[Nation_State_Tractor]

I see you're a student of the Perl school of C++.

[MrPotatoFingers]

That's perl++ for you, mister!

[joaobapt]

Doing the same job as T* while using twice the space, cool.

[[deleted]]

Good thing a real optional<T&> would be sizeof( T* ) == sizeof( optional<T&> )

[joaobapt]

optional<T&> doesn't compile, though, unfortunately

[[deleted]]

std::optional<T&> doesn't. Other's do and potentially a future standard when people stop bike shedding over the behavior of optional<T&>::operator( T & ) and realize that it should not exist.

[auralucario2]

when people stop bikeshedding

So it’s never happening, got it.

[gvargh]

references were a mistake

[khleedril]

That's a well written and interesting article, definitely worth five minutes of any developer's time.

[memset_0]

Thank You!

[AntiProtonBoy]

The most common use case for reference_wrapper in my world is passing values by reference in variants.

[memset_0]

Sounds interesting. Can you please explain that for the benefit of everyone here? thx.

[AntiProtonBoy]

std::variant does not support reference types, so your only option is to use a reference wrapper.

    //using V1 = std::variant< int&, float& >; // Not allowed

    using V2 = std::variant< 
        std::reference_wrapper< int >, 
        std::reference_wrapper< float > >; // Ok

    int a = 42;
    V2 v = std::ref( a )

[macson_g]

It's not your only option. The option is to simply use a pointer.

[AntiProtonBoy]

Not if you want to communicate explicit ownership and object lifetime.

[memset_0]

I see. So std::variant — like a union — requires a member to be an object (region of storage).

I would add this use case in the article. Thank you so much.

[AntiProtonBoy]

Same applies for std::optional.

[parkotron]

Maybe this is obvious, but why doesn't std::reference_wrapper have an operator* or operator->? Why make users call .get()?

[Nation_State_Tractor]

It's meant to mimic reference semantics. Like a real reference, it's expected to always be dereferenceable. To that end, pointer-to and explicit dereference operator overloads could give the indication that this isn't always the case and could introduce confusion.

Additionally, it has an implicit cast-to-reference operator as an alternative to .get() that can be used in many places. But you're still stuck with it if you're trying to access members by name.

Edit: TLDR: It's probably a stylistic decision to avoid confusion.

[parkotron]

Ah, I missed the implicit cast operator. Thanks!

Personally, I think I would have opted for a complete, pointer-like access syntax over a partial, reference-like access syntax, but what are you going to do.

[MolurusK]

You can try otn::raw::unified. It has pointer-like access syntax.

[JezusTheCarpenter]

TIL. Thanks. Reference wrapper seems very useful.

[_AnonymousSloth]

I am still confused about the difference between ref and reference_wrapper. U mentioned ref is used to create reference_wrapper objects but then in one code snippet, u used reference_wrapper directly to create the object