The Linux Manuals (man pages) document is an important part of Linux documents. Linux Manuals are organized as several sections. Each section has a group of commands for a specific area in Linux usage, administration or development.
std::future_category – std::future_category Synopsis Defined in header <future> const std::error_category& future_category() noexcept; (since C++11) Obtains a reference to the static error category object for the errors related to futures and promises. The object is required to override the virtual function error_category::name() to return a pointer to the string "future". It is used to identify error…
std::future<T>::wait_until – std::future<T>::wait_until Synopsis template <class Clock, class Duration> (since C++ 11) std::future_status wait_until(const std::chrono::time_point<Clock, Duration> &timeout_time) const; wait_until waits for a result to become available. It blocks until specified timeout_time has been reached or the result becomes available, whichever comes first. The return value indicates why wait_until returned. The behavior is undefined if valid()==…
std::future<T>::wait_for – std::future<T>::wait_for Synopsis template <class Rep, class Period> (since C++ 11) std::future_status wait_for(const std::chrono::duration<Rep, Period> &timeout_duration) const; Waits for the result to become available. Blocks until specified timeout_duration has elapsed or the result becomes available, whichever comes first. Returns value identifies the state of the result. This function may block for longer than timeout_duration…
std::future<T>::wait – std::future<T>::wait Synopsis void wait() const; (since C++ 11) Blocks until the result becomes available. valid() == true after the call. The behavior is undefined if valid()== false before the call to this function. Parameters (none) Return value (none) Exceptions (none) Notes The implementations are encouraged to detect the case when valid == false…
std::future<T>::valid – std::future<T>::valid Synopsis bool valid() const noexcept; (since C++11) Checks if the future refers to a shared state. This is the case only for futures that were not default-constructed or moved from (i.e. returned by std::promise::get_future(), std::packaged_task::get_future() or std::async()) until the first time get() or share() is called. The behavior is undefined if any…
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…