Public Types | Public Member Functions | Private Attributes
ecl::ReferenceWrapper< T > Class Template Reference

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

#include <references.hpp>

List of all members.

Public Types

typedef T type

Public Member Functions

 operator T & () const
 Convenience operator for converting to the underlying reference directly.
T * pointer () const
 Accessor to a pointer to the original instance.
T & reference () const
 Accessor to the reference of the original instance.
 ReferenceWrapper (T &t)
 Constructs the wrapper around the supplied object instance.
virtual ~ReferenceWrapper ()

Private Attributes

T * obj_ptr

Detailed Description

template<typename T>
class ecl::ReferenceWrapper< T >

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.

Definition at line 85 of file references.hpp.


Member Typedef Documentation

template<typename T>
typedef T ecl::ReferenceWrapper< T >::type

Convenient handle to the reference wrapper's base type.

Definition at line 88 of file references.hpp.


Constructor & Destructor Documentation

template<typename T>
ecl::ReferenceWrapper< T >::ReferenceWrapper ( T &  t) [inline]

Constructs the wrapper around the supplied object instance.

Constructs the wrapper around the supplied object instance.

Parameters:
t: the object instance.

Definition at line 97 of file references.hpp.

template<typename T>
virtual ecl::ReferenceWrapper< T >::~ReferenceWrapper ( ) [inline, virtual]

Definition at line 99 of file references.hpp.


Member Function Documentation

template<typename T>
ecl::ReferenceWrapper< T >::operator T & ( ) const [inline]

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.

Definition at line 109 of file references.hpp.

template<typename T>
T* ecl::ReferenceWrapper< T >::pointer ( ) const [inline]

Accessor to a pointer to the original instance.

Returns a pointer to the wrapped object.

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

Definition at line 127 of file references.hpp.

template<typename T>
T& ecl::ReferenceWrapper< T >::reference ( ) const [inline]

Accessor to the reference of the original instance.

Returns a reference to the wrapped object.

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

Definition at line 118 of file references.hpp.


Member Data Documentation

template<typename T>
T* ecl::ReferenceWrapper< T >::obj_ptr [private]

Definition at line 130 of file references.hpp.


The documentation for this class was generated from the following file:


ecl_utilities
Author(s): Daniel Stonier
autogenerated on Wed Aug 26 2015 11:27:20