function — Klasa

Otoka dla wywoływanego obiektu.

Składnia

template <class Fty>
class function  // Fty of type Ret(T1, T2, ..., TN)
    : public unary_function<T1, Ret>       // when Fty is Ret(T1)
    : public binary_function<T1, T2, Ret>  // when Fty is Ret(T1, T2)
{
public:
    typedef Ret result_type;

    function();
    function(nullptr_t);
    function(const function& right);
    template <class Fty2>
        function(Fty2 fn);
    template <class Fty2, class Alloc>
        function(reference_wrapper<Fty2>, const Alloc& Ax);

    template <class Fty2, class Alloc>
        void assign(Fty2, const Alloc& Ax);
    template <class Fty2, class Alloc>
        void assign(reference_wrapper<Fty2>, const Alloc& Ax);
    function& operator=(nullptr_t);
    function& operator=(const function&);
    template <class Fty2>
        function& operator=(Fty2);
    template <class Fty2>
        function& operator=(reference_wrapper<Fty2>);

    void swap(function&);
    explicit operator bool() const;

    result_type operator()(T1, T2, ....., TN) const;
    const std::type_info& target_type() const;
    template <class Fty2>
        Fty2 *target();

    template <class Fty2>
        const Fty2 *target() const;

    template <class Fty2>
        void operator==(const Fty2&) const = delete;
    template <class Fty2>
        void operator!=(const Fty2&) const = delete;
};

Parametry

Fty
Typ funkcji do zawijania.

Siekiera
Funkcja alokatora.

Uwagi

Szablon klasy to otoka wywołań, której podpis wywołania to Ret(T1, T2, ..., TN). Służy do ujęć w różne obiekty wywoływane w jednolitą otokę.

Niektóre funkcje członkowskie przyjmują operand, który nazywa żądany obiekt docelowy. Taki operand można określić na kilka sposobów:

fn: obiekt fnwywoływany ; po wywołaniu function obiektu przechowuje kopię fn

fnref: obiekt wywoływany o nazwie by fnref.get(); po wywołaniu function obiektu przechowuje odwołanie do fnref.get()

right: obiekt wywoływany, jeśli istnieje, przechowywany przez function obiekt right

npc: wskaźnik o wartości null; po wywołaniu function obiektu jest pusty

We wszystkich przypadkach , INVOKE(f, t1, t2, ..., tN)gdzie f jest obiektem wywoływanym i t1, t2, ..., tN są lvalues odpowiednio typów T1, T2, ..., TN , muszą być dobrze sformułowane i, jeśli Ret nie jest void, kabriolet do Ret.

function Pusty obiekt nie zawiera wywoływanego obiektu ani odwołania do obiektu, który można wywołać.

Elementy członkowskie

Konstruktory

Nazwa/nazwisko	opis
funkcja	Tworzy otokę, która jest pusta lub przechowuje wywoływany obiekt dowolnego typu ze stałym podpisem.

Typedefs

Nazwa/nazwisko	opis
result_type	Zwracany typ przechowywanego obiektu wywołującego.

Funkcje

Nazwa/nazwisko	opis
przypisać	Przypisuje obiekt, który można wywołać do tego obiektu funkcji.
zamiana	Zamiana dwóch obiektów możliwych do wywołania.
cel	Sprawdza, czy przechowywany obiekt wywołujący jest wywoływany zgodnie z określonymi.
target_type	Pobiera informacje o typie obiektu, który można wywołać.

Operatory

Nazwa/nazwisko	opis
operator nieokreślony	Sprawdza, czy istnieje przechowywany obiekt wywołujący.
operator()	Wywołuje obiekt, który można wywołać.
operator =	Zastępuje przechowywany obiekt wywoływany.

przypisywanie

Przypisuje obiekt, który można wywołać do tego obiektu funkcji.

template <class Fx, class Alloc>
    void assign(
        Fx _Func,
        const Alloc& Ax);

template <class Fx, class Alloc>
    void assign(
        reference_wrapper<Fx> _Fnref,
        const Alloc& Ax);

Parametry

_Func
Obiekt, który można wywołać.

_Fnref
Otoka odwołania zawierająca obiekt wywoływany.

Siekiera
Obiekt alokatora.

Uwagi

Funkcje składowe zastępują przechowywane przez callable object *this element obiektem wywoływanym przekazanym operandjako . Oba przydzielają magazyn z osią obiektu alokatora.

function

Tworzy otokę, która jest pusta lub przechowuje wywoływany obiekt dowolnego typu ze stałym podpisem.

function();
function(nullptr_t npc);
function(const function& right);
template <class Fx>
    function(Fx _Func);
template <class Fx>
    function(reference_wrapper<Fx> _Fnref);
template <class Fx, class Alloc>
    function(
        Fx _Func,
        const Alloc& Ax);

template <class Fx, class Alloc>
    function(
        reference_wrapper<Fx> _Fnref,
        const Alloc& Ax);

Parametry

Prawy
Obiekt funkcji do skopiowania.

Fx
Typ wywoływanego obiektu.

_Func
Obiekt wywoływany do opakowania.

Alloc
Typ alokatora.

Siekiera
Alokator.

_Fnref
Odwołanie do obiektu wywoływanego w celu zawijania.

Uwagi

Dwa pierwsze konstruktory skonstruuje pusty function obiekt. Następne trzy konstruktory skonstruują function obiekt, który przechowuje obiekt wywoływany przekazywany jako operand. Dwa ostatnie konstruktory przydzielają magazyn z osią obiektu alokatora.

Przykład

// std__functional__function_function.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>
#include <vector>

int square(int val)
{
    return val * val;
}

class multiply_by
{
public:
    explicit multiply_by(const int n) : m_n(n) { }

    int operator()(const int x) const
    {
        return m_n * x;
    }

private:
    int m_n;
};

int main()
{
    typedef std::vector< std::function<int (int)> > vf_t;

    vf_t v;
    v.push_back(square);
    v.push_back(std::negate<int>());
    v.push_back(multiply_by(3));

    for (vf_t::const_iterator i = v.begin(); i != v.end(); ++i)
    {
        std::cout << (*i)(10) << std::endl;
    }

    std::function<int (int)> f = v[0];
    std::function<int (int)> g;

    if (f) {
        std::cout << "f is non-empty (correct)." << std::endl;
    } else {
        std::cout << "f is empty (can't happen)." << std::endl;
    }

    if (g) {
        std::cout << "g is non-empty (can't happen)." << std::endl;
    } else {
        std::cout << "g is empty (correct)." << std::endl;
    }

    return 0;
}

100
-10
30
f is non-empty (correct).
g is empty (correct).

operator nieokreślony

Sprawdza, czy istnieje przechowywany obiekt wywołujący.

operator unspecified();

Uwagi

Operator zwraca wartość, która jest konwertowana na bool wartość true tylko wtedy, gdy obiekt nie jest pusty. Służy do testowania, czy obiekt jest pusty.

Przykład

// std__functional__function_operator_bool.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0;
    std::cout << std::boolalpha << "not empty == " << (bool)fn0 << std::endl;

    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "not empty == " << (bool)fn1 << std::endl;

    return (0);
    }

not empty == false
not empty == true

operator()

Wywołuje obiekt, który można wywołać.

result_type operator()(
    T1 t1,
    T2 t2, ...,
    TN tN);

Parametry

TN
Typ argumentu wywołania Nth.

Tn
Argument wywołania Nth.

Uwagi

Funkcja składowa zwraca INVOKE(fn, t1, t2, ..., tN, Ret)element , gdzie fn jest obiektem docelowym przechowywanym w *thiselemencie . Służy do wywoływania opakowanego obiektu wywołującego.

Przykład

// std__functional__function_operator_call.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3

operator =

Zastępuje przechowywany obiekt wywoływany.

function& operator=(null_ptr_type npc);
function& operator=(const function& right);
template <class Fty>
    function& operator=(Fty fn);
template <class Fty>
    function& operator=(reference_wrapper<Fty> fnref);

Parametry

Npc
Stała wskaźnika o wartości null.

Prawy
Obiekt funkcji do skopiowania.

Fn
Obiekt wywoływany do opakowania.

fnref
Odwołanie do obiektu wywoływanego w celu zawijania.

Uwagi

Operatory, z których każdy zastępuje obiekt wywoływany przechowywany za *this pomocą obiektu wywoływanego przekazanego jako operand.

Przykład

// std__functional__function_operator_as.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "val == " << fn0(3) << std::endl;

    std::function<int (int)> fn1;
    fn1 = 0;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;

    fn1 = neg;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    fn1 = fn0;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    fn1 = std::cref(fn1);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3
empty == true
empty == false
val == -3
empty == false
val == -3
empty == false
val == -3

result_type

Zwracany typ przechowywanego obiektu wywołującego.

typedef Ret result_type;

Uwagi

Typedef jest synonimem typu Ret w podpisie wywołania szablonu. Służy do określania typu zwrotnego opakowanego obiektu wywoływanego.

Przykład

// std__functional__function_result_type.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;

    std::function<int (int)>::result_type val = fn1(3);
    std::cout << "val == " << val << std::endl;

    return (0);
    }

empty == false
val == -3

swap

Zamiana dwóch obiektów możliwych do wywołania.

void swap(function& right);

Parametry

Prawy
Obiekt funkcji do zamiany.

Uwagi

Funkcja składowa zamienia obiekty docelowe między *this i po prawej stronie. Robi to w stałym czasie i nie zgłasza żadnych wyjątków.

Przykład

// std__functional__function_swap.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "val == " << fn0(3) << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << std::endl;

    fn0.swap(fn1);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3
empty == true

empty == true
empty == false
val == -3

target

Sprawdza, czy przechowywany obiekt wywołujący jest wywoływany zgodnie z określonymi.

template <class Fty2>
    Fty2 *target();
template <class Fty2>
    const Fty2 *target() const;

Parametry

Fty2
Docelowy typ obiektu wywołującego do przetestowania.

Uwagi

Typ Fty2 musi być wywoływany dla typów argumentów T1, T2, ..., TN i zwracany typ Ret. Jeśli target_type() == typeid(Fty2)funkcja szablonu elementu członkowskiego zwraca adres obiektu docelowego; w przeciwnym razie zwraca wartość 0.

Typ Fty2 jest wywoływany dla typów T1, T2, ..., TN argumentów i zwracany typ Ret , jeśli dla lvalues fn, t1, t2, ..., tN typów Fty2, T1, T2, ..., TN, odpowiednio, INVOKE(fn, t1, t2, ..., tN) jest poprawnie sformułowany i, jeśli Ret nie voidjest , kabriolet do Ret.

Przykład

// std__functional__function_target.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    typedef int (*Myfun)(int);
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "no target == " << (fn0.target<Myfun>() == 0) << std::endl;

    Myfun *fptr = fn0.target<Myfun>();
    std::cout << "val == " << (*fptr)(3) << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "no target == " << (fn1.target<Myfun>() == 0) << std::endl;

    return (0);
    }

empty == false
no target == false
val == -3
empty == true
no target == true

target_type

Pobiera informacje o typie obiektu, który można wywołać.

const std::type_info& target_type() const;

Uwagi

Funkcja składowa zwraca typeid(void) wartość , jeśli *this jest pusta, w przeciwnym razie zwraca typeid(T)wartość , gdzie T jest typem obiektu docelowego.

Przykład

// std__functional__function_target_type.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "type == " << fn0.target_type().name() << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "type == " << fn1.target_type().name() << std::endl;

    return (0);
    }

empty == false
type == int (__cdecl*)(int)
empty == true
type == void