Linux Manuals session 3

std::future<T>::share – std::future<T>::share Synopsis std::shared_future<T> share() noexcept; Transfers the shared state of *this, if any, to a std::shared_future object. Multiple std::shared_future objects may reference the same shared state, which is not possible with std::future. After calling share on a std::future, valid() == false. Parameters (none) Return value A std::shared_future object containing the shared state previously…

std::future<T>::operator= – std::future<T>::operator= Synopsis future &operator=(future &&other) noexcept; (1)(since C++ 11) future & operator=(const future &other) = delete; (2)(since C++ 11) Assigns the contents of another future object. 1) Releases any shared state and move-assigns the contents of other to *this. After the assignment, other.valid() == false and this->valid() will yield the same value as…

std::future<T>::get – std::future<T>::get Synopsis T get(); (1) (member only of generic future template)                 (since C++11) T& get(); (2) (member only of future<T&> template specialization)                 (since C++11) void get(); (3) (member only of future<void> template specialization)                 (since C++11) The get method waits until the future has a valid result and (depending on which template is used)…

std::future<T>::~future – std::future<T>::~future Synopsis ~future(); (since C++11) Releases any shared state. This means *if the return object or provider holds the last reference to its shared state, the shared state is destroyed; and *the return object or provider gives up its reference to its shared state; and * these actions will not block for the…

std::future – std::future Synopsis Defined in header <future> template< class T > class future; (1) (since C++11) template< class T > class future<T&>; (2) (since C++11) template<> class future<void>; (3) (since C++11) The class template std::future provides a mechanism to access the result of asynchronous operations: * An asynchronous operation (created via std::async, std::packaged_task, or…

std::function<R(Args…)>::target_type – std::function<R(Args…)>::target_type Synopsis const std::type_info &target_type() const noexcept; (since C++ 11) Returns the type of the stored function. Parameters (none) Return value typeid(T) if the stored function has type T, otherwise typeid(void) Example // Run this code #include <functional> #include <iostream> int f(int a) { return -a; } int main() { // fn1 and…

std::function<R(Args…)>::target – std::function<R(Args…)>::target Synopsis template <class T> (1)(since C++ 11) T *target() noexcept; template <class T> (2)(since C++ 11) const T *target() const noexcept; Returns a pointer to the stored callable function target. Parameters (none) Return value A pointer to the stored function if target_type() == typeid(T), otherwise a null pointer. Example // Run this…

std::function<R(Args…)>::swap – std::function<R(Args…)>::swap Synopsis void swap(function &other) noexcept; (since C++ 11) Exchanges the stored callable objects of *this and other. Parameters other – function wrapper to exchange the stored callable object with Return value (none)

std::function<R(Args…)>::operatorbool – std::function<R(Args…)>::operatorbool Synopsis explicit operator bool() const noexcept; (since C++11) Checks whether *this stores a callable function target, i.e. is not empty. Parameters (none) Return value true if *this stores a callable function target, false otherwise. Example // Run this code #include <functional> #include <iostream> void sampleFunction() { std::cout << "This is the sample…

std::function<R(Args…)>::operator= – std::function<R(Args…)>::operator= Synopsis function &operator=(const function &other); (1)(since C++ 11) function & operator=(function &&other); (2)(since C++ 11) function & operator=(std::nullptr_t); (since C++ 11)(until C++ 17) function & operator=(std::nullptr_t) noexcept; (since C++ 17) template <class F> (3)(4)(since C++ 11) function & operator=(F &&f); template <class F> (5)(since C++ 11) function & operator=(std::reference_wrapper<F> f) noexcept; Assigns…

std::function<R(Args…)>::~function – std::function<R(Args…)>::~function Synopsis ~function(); (since C++11) Destroys the std::function instance. If the std::function is not empty, its target is destroyed also.

std::function<R(Args…)>::assign – std::function<R(Args…)>::assign Synopsis template< class F, class Alloc > (since C++11) void assign( F&& f, const Alloc& alloc ); (removed in C++17) Initializes the target with f. alloc is used to allocate memory for any internal data structures that the function might use. Equivalent to function(allocator_arg, alloc, std::forward<F>(f)).swap(*this) Parameters f – callable function to…

std::function – std::function Synopsis Defined in header <functional> template< class > (since C++11) class function; /* undefined */ template< class R, class… Args > (since C++11) class function<R(Args…)>; Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any Callable target — functions, lambda_expressions, bind_expressions, or other function…

std::ftell – std::ftell Synopsis Defined in header <cstdio> long ftell( std::FILE* stream ); Returns the current value of the file position indicator for the file stream stream. If the stream is open in binary mode, the value obtained by this function is the number of bytes from the beginning of the file. If the stream…

std::basic_fstream – std::basic_fstream Synopsis Defined in header <fstream> template< class CharT, class Traits = std::char_traits<CharT> > class basic_fstream : public std::basic_iostream<CharT, Traits> The class template basic_fstream implements high-level input/output operations on file based streams. It interfaces a file-based streambuffer (std::basic_filebuf) with the high-level interface of (std::basic_iostream). A typical implementation of std::basic_fstream holds only one non-derived…

std::fsetpos – std::fsetpos Synopsis Defined in header<cstdio> int fsetpos(std::FILE *stream, const std::fpos_t *pos); Sets the file position indicator and the multibyte parsing state (if any) for the C file stream stream according to the value pointed to by pos. Besides establishing new parse state and position, a call to this function undoes the effects of…

std::fseek – std::fseek Synopsis Defined in header<cstdio> int fseek(std::FILE *stream, long offset, int origin); Sets the file position indicator for the file stream stream. If the stream is open in binary mode, the new position is exactly offset bytes measured from the beginning of the file if origin is SEEK_SET, from the current file position…

std::front_inserter – std::front_inserter Synopsis Defined in header <iterator> template< class Container > (until C++20) std::front_insert_iterator<Container> front_inserter( Container& c ); template< class Container > (since C++20) constexpr std::front_insert_iterator<Container> front_inserter( Container& c ); front_inserter is a convenience function template that constructs a std::front_insert_iterator for the container c with the type deduced from the type of the argument….

std::front_insert_iterator<Container>::operator= – std::front_insert_iterator<Container>::operator= Synopsis front_insert_iterator<Container> &(until C++ 11) operator=(typename Container::const_reference value); front_insert_iterator<Container> &(since C++ 11) operator=(const typename Container::value_type &value); (until C++ 20) constexpr front_insert_iterator<Container> &(1)(since C++ 20) operator=(const typename Container::value_type &value); front_insert_iterator<Container> &(since C++ 11) operator=(typename Container::value_type &&value); (2)(until C++ 20) constexpr front_insert_iterator<Container> &(since C++ 20) operator=(typename Container::value_type &&value); Inserts the given value value to…

std::front_insert_iterator<Container>::front_insert_iterator – std::front_insert_iterator<Container>::front_insert_iterator Synopsis constexpr front_insert_iterator() noexcept = default; (1) (since C++20) explicit front_insert_iterator( Container& c ); (2) (until C++20) constexpr explicit front_insert_iterator( Container& c ); (since C++20) 1) Initializes the underlying pointer to container with nullptr. (since C++20) 2) Initializes the underlying pointer to the container to std::addressof(c). Parameters c – container to initialize…