Template Class ReferenceWrapper

Defined in File references.hpp

Class Documentation

template<typename T> class ReferenceWrapper

Provides a wrapper which allows the original object to be passed like a reference.

This class wraps the supplied object, storing it as a pointer and allowing it to be passed like a regular object. By itself, this is not terribly useful, but in combination with the ref/cref functions and also the is_reference_wrapper trait, it allows things like functions and function objects to be easily manipulated.

Note: reference wrappers might seem a bit redundant - why do we need them? The following case illustrates a desired usage scenario.

class A {
public:
    template <typename T>
    void f(T i) { cout << "Not a reference input" << endl; }

    template <typename T>
    void f(T &i) { cout << "A reference input" << endl; }
}

Unfortunately, when you come to call this function, you’ll get an ambiguity error.

In these situations you can use a simple function call (not ref) and pass in this reference wrapper:

class A {
public:
    template <typename T>
    void f(const T &t) {
        if ( is_reference_wrapper<T> ) {
            // do something for references
        } else {
            // do something for non-references
        }
    }
}

Template Parameters:: T – : the type of object this class is wrapping.

Public Types

typedef T type: Convenient handle to the reference wrapper’s base type.

Public Functions

inline ReferenceWrapper(T &t)

Constructs the wrapper around the supplied object instance.

Parameters:: t – : the object instance.

inline virtual ~ReferenceWrapper()

inline operator T&() const

Convenience operator for converting to the underlying reference directly.

When used where the underlying reference is expected, this automatically handles the conversion.

Returns:: T& : the returned reference to the wrapped object.

inline T &reference() const

Accessor to the reference of the original instance.

Returns a reference to the wrapped object.

Returns:: T& : the returned reference to the wrapped object.

inline T *pointer() const

Accessor to a pointer to the original instance.

Returns a pointer to the wrapped object.

Returns:: T& : the returned pointer to the wrapped object.