Binder Classes(3)

NAME
Binder Classes -

  Classes
class std::binder1st< _Operation >
One of the binder functors.
class std::binder2nd< _Operation >
One of the binder functors.

  Functions
template<typename _Operation , typename _Tp > binder1st< _Operation > std::bind1st (const _Operation &__fn, const _Tp &__x)
template<typename _Operation , typename _Tp > binder2nd< _Operation > std::bind2nd (const _Operation &__fn, const _Tp &__x)

  Variables
struct std::auto_ptr_ref std::_GLIBCXX_DEPRECATED_ATTR

Detailed Description

Binders turn functions/functors with two arguments into functors with a single argument, storing an argument to be applied later. For example, a variable B of type binder1st is constructed from a functor f and an argument x. Later, B's operator() is called with a single argument y. The return value is the value of f(x,y). B can be 'called' with various arguments (y1, y2, ...) and will in turn call f(x,y1), f(x,y2), ...

The function bind1st is provided to save some typing. It takes the function and an argument as parameters, and returns an instance of binder1st.

The type binder2nd and its creator function bind2nd do the same thing, but the stored argument is passed as the second parameter instead of the first, e.g., bind2nd(std::minus<float>,1.3) will create a functor whose operator() accepts a floating-point number, subtracts 1.3 from it, and returns the result. (If bind1st had been used, the functor would perform '1.3 - x' instead.

Creator-wrapper functions like bind1st are intended to be used in calling algorithms. Their return values will be temporary objects. (The goal is to not require you to type names like std::binder1st<std::plus<int>> for declaring a variable to hold the return value from bind1st(std::plus<int>,5).

These become more useful when combined with the composition functions.

Function Documentation

  template<typename _Operation , typename _Tp > binder1st<_Operation> std::bind1st (const _Operation & __fn, const _Tp & __x) [inline]

One of the binder functors.

Definition at line 129 of file binders.h.

  template<typename _Operation , typename _Tp > binder2nd<_Operation> std::bind2nd (const _Operation & __fn, const _Tp & __x) [inline]

One of the binder functors.

Definition at line 164 of file binders.h.

Variable Documentation

  std::binder2nd std::_GLIBCXX_DEPRECATED_ATTR

A simple smart pointer providing strict ownership semantics.

One of the binder functors.

A wrapper class to provide auto_ptr with reference semantics. For example, an auto_ptr can be assigned (or constructed from) the result of a function which returns an auto_ptr by value.

All the auto_ptr_ref stuff should happen behind the scenes.

The Standard says:

  An auto_ptr owns the object it holds a pointer to.  Copying
  an auto_ptr copies the pointer and transfers ownership to the
  destination.  If more than one auto_ptr owns the same object
  at the same time the behavior of the program is undefined.

  The uses of auto_ptr include providing temporary
  exception-safety for dynamically allocated memory, passing
  ownership of dynamically allocated memory to a function, and
  returning dynamically allocated memory from a function.  auto_ptr does not meet the CopyConstructible and Assignable
  requirements for Standard Library container elements and thus
  instantiating a Standard Library container with an auto_ptr results in undefined behavior.

 Quoted from [20.4.5]/3.

Good examples of what can and cannot be done with auto_ptr can be found in the libstdc++ testsuite.

_GLIBCXX_RESOLVE_LIB_DEFECTS 127. auto_ptr<> conversion issues These resolutions have all been incorporated.

Author

Generated automatically by Doxygen for libstdc++ from the source code.