#include <Containers/Reference.h>
template<class T>
Death::Containers::Reference class

Lightweight non-owning reference wrapper.

Equivalent to std::reference_wrapper from C++11, provides a copyable non-owning wrapper over l-value references to allow storing them in containers. Unlike std::reference_wrapper, this class does not provide operator() and there are no equivalents to std::ref() / std::cref() as they are not deemed necessary — in most contexts where Reference is used, passing a plain reference works just as well. This class is trivially copyable (std::reference_wrapper is guaranteed to be so only since C++17) and also works on incomplete types, which std::reference_wrapper knows since C++20.

This class is exclusively for l-value references.

Constructors, destructors, conversion operators

Reference(T& reference) constexpr noexcept
template<class U, class = decltype(Implementation::ReferenceConverter<T, U>::from(std::declval<U>()))>
Reference(U other) constexpr noexcept
Construct a reference from external representation.
Reference(T&&) deleted
Construction from r-value references is not allowed.
template<class U, class = typename std::enable_if<std::is_base_of<T, U>::value>::type>
Reference(Reference<U> other) constexpr noexcept
Construct a reference from another of a derived type.
template<class U, class = decltype(Implementation::ReferenceConverter<T, U>::to(std::declval<Reference<T>>()))>
operator U() const constexpr
Convert the reference to external representation.
operator T&() const constexpr
Underlying reference.
operator Reference<const T>() const constexpr

Public functions

auto get() const -> T& constexpr
Underlying reference.
auto operator->() const -> T* constexpr
Access the underlying reference.
auto operator*() const -> T& constexpr
Access the underlying reference.

Function documentation

template<class T> template<class U, class = typename std::enable_if<std::is_base_of<T, U>::value>::type>
Death::Containers::Reference<T>::Reference(Reference<U> other) constexpr noexcept

Construct a reference from another of a derived type.

Expects that T is a base of U.

template<class T>
Death::Containers::Reference<T>::operator Reference<const T>() const constexpr

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class T> template<class T>
Reference<T> reference(T& reference) constexpr

Make a reference wrapper.

Convenience alternative to Reference::Reference(T&).

Useful for example when iterating a list of variables that need to be modified in-place, and where the code would otherwise have to be extra verbose or would fall back to raw pointers and risk them getting nullptr.