<functional>

Backports related to Standard header <functional>

#include <cxxomfort/functional.hpp>
// or as part of:
#include <cxxomfort/backports.hpp>

Interfaces

Interfaces defined in this section:

• Bit functoids bit_and , bit_or , bit_xor (C++98, only for some older compilers).
• reference_wrapper (C++03/TR1) and its assisting functions.
• mem_fn() wrapper (C++11) (only for some compilers)
• Transparent / Heterogegenous Functors (C++14).
• not_fn() (C++17) - generalically negate any functor.
• invoke() / invoke_r() invocation of callables (C++17, C++20), for C++11-onward only.
• unwrap_reference (C++20).
• bind_front() (C++20) - for C++11-onward only.

The following interfaces are repointed to namespace std:: when found in namespace std::tr1:: :

• std::reference_wrapper , std::ref() , std::cref() - object wrapper and related utilities.
• std::bind() - function wrapper and related utilities.
• std::placeholders::_* from _1 to _9 .
• std::mem_fn() - member function adapter.
• std::function - function/callable wrapper
• std::hash - generic hashing

The following interfaces are provided by cxxomfort when CXOMFORT_USE_INTERNAL_TR1 is defined:

• cxxomfort::cxxostd::reference_wrapper , std::ref() , std::cref() .
• std::placeholders::_* from _1 to _9 .
• std::mem_fn() .

Non-backport interfaces (cxxomfort::fix):

• hash - Extra-power, specializable forwarder to std::hash .

Callable Invocation with std::invoke

Cxxomfort implements a backport of std::invoke() from C++17 and std::invoke_r() from C++20 for C++11 onwards, and for certain compilers in C++03 mode. The feature is implemented and functions differently depending on the compiler and Standard mode.

• For compilers supporting at least C++11, invoke() is implemented via trailing return type and should be capable of handing any callable type and any return type generated.
• For compilers supporting typeof , invoke() is implemented via deduced return type, which could cause the callable to be invoked twice.
• For compilers without at least typeof support, invoke() is not provided.

Additionally, cxxomfort sets the SD6 macros __cpp_lib_invoke and __cpp_lib_invoke_r when it backports (not emulates) these facilities.

Notes

Note

Cxxomfort expects an implementation of std::reference_wrapper and related utilities to exist and function in order, as part of the general TR1 requirement.

Cxxomfort expects an implementation of std::bind and related utilities to exist and function in order, as part of the general TR1 requirement.

"Planned for the future"

• Recovered function adaptors bind1st() , bind2nd() and ptr_fun (C++17/C++20).

See Also

See also

header/functional @ cppreference

utility/functional/reference_wrapper @ cppreference

utility/functional/not_fn @ cppreference

cxxomfort <functional> supplements

Member cxxomfort::cxxostd::cref (T const &t) CXXO_NOEXCEPTNOTHROW

"std::reference_wrapper"

Member cxxomfort::cxxostd::invoke (F &&callable, Args &&... args)

Invokes callables via callable( args... ), accounting for eg.: member-pointer callables.

Member cxxomfort::cxxostd::invoke_r (F &&callable, Args &&... args)

Invoke callables via (R)callable( args... ), specifying the return type.

Member cxxomfort::cxxostd::ref (T &t) CXXO_NOEXCEPTNOTHROW

"std::reference_wrapper"

File functional.hpp

Class reference_wrapper< T >

"std::reference_wrapper"

A reference_wrapper hosts a reference to an object in the same way a normal reference does, but separates assignment mechanics so that assigning to the wrapper changes whichobject is hosted, instead of changing the object itself. It basically behaves as a pointer-to-T.