Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.com/function::function below:

public member function

<functional>

function() noexcept;function (nullptr_t fn) noexcept;

template <class Fn> function (Fn fn);

function (const function& x);

function (function&& x);

template <class Alloc>  function (allocator_arg_t aa, const Alloc& alloc) noexcept;template <class Alloc>  function (allocator_arg_t aa, const Alloc& alloc, nullptr_t fn) noexcept;template <class Fn, class Alloc>  function (allocator_arg_t aa, const Alloc& alloc, Fn fn);template <class Alloc>  function (allocator_arg_t aa, const Alloc& alloc, const function& x);template <class Alloc>  function (allocator_arg_t aa, const Alloc& alloc, function&& x);

Construct function wrapper

(1) default / empty

Constructs an empty function object (with no target).

(2) initialization

The object stores a decayed copy of fn as its target.

fn shall be callable for the arguments and return type specified as template arguments for the class.

If fn is not callable for the arguments and return type specified as template arguments for the class, this constructor does not participate in overload resolution.

(3) copy constructor

The object stores a copy of x's target (x.target()).

(4) move constructor

The object acquires x's target.
x is left in an unspecified but valid state.

(5) versions with allocator

Same as the versions above, but the object stores alloc and uses it to allocate internal storage, if necessary.
Library implementations may optimize for small callable objects (such as when the target is a function pointer) and not use dynamically allocated memory for objects targeting these.

fn

Either a function, a function pointer, a pointer to member, or any kind of copy-constructible function object (i.e., an object whose class defines operator(), including closures and other instantiations of function).
If fn is a null pointer, a null member pointer or an empty function object, the object is initialized as an empty function.
Otherwise, the object is initialized to target a decayed copy of fn (internally initialized with std::move(fn)).

x

A function object of the same type (with the same signature, as described by its template parameters) whose target is either copied or moved into *this.
If x is an empty function object, the object is initialized as an empty function.

aa

The std::allocator_arg value. This constant value is merely used to select the constructor forms with an allocator parameter.

alloc

Allocator object used to allocate internal memory, if necessary.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// function example
#include <iostream>     // std::cout
#include <functional>   // std::function, std::negate

// a function:
int half(int x) {return x/2;}

// a function object class:
struct third_t {
  int operator()(int x) {return x/3;}
};

// a class with data members:
struct MyValue {
  int value;
  int fifth() {return value/5;}
};

int main () {
  std::function<int(int)> fn1 = half;                    // function
  std::function<int(int)> fn2 = &half;                   // function pointer
  std::function<int(int)> fn3 = third_t();               // function object
  std::function<int(int)> fn4 = [](int x){return x/4;};  // lambda expression
  std::function<int(int)> fn5 = std::negate<int>();      // standard function object

  std::cout << "fn1(60): " << fn1(60) << '\n';
  std::cout << "fn2(60): " << fn2(60) << '\n';
  std::cout << "fn3(60): " << fn3(60) << '\n';
  std::cout << "fn4(60): " << fn4(60) << '\n';
  std::cout << "fn5(60): " << fn5(60) << '\n';

  // stuff with members:
  std::function<int(MyValue&)> value = &MyValue::value;  // pointer to data member
  std::function<int(MyValue&)> fifth = &MyValue::fifth;  // pointer to member function

  MyValue sixty {60};

  std::cout << "value(sixty): " << value(sixty) << '\n';
  std::cout << "fifth(sixty): " << fifth(sixty) << '\n';

  return 0;
}

fn1(60): 30
fn2(60): 30
fn3(60): 20
fn4(60): 15
fn5(60): -60
value(sixty): 60
fifth(sixty): 12

function::operator=

Assign function object (public member function)

swap (function)

Exchanges the targets (public member function)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4