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:

• references.hpp