function — Klasa

Artykuł
10/12/2023

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.

Ax
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ć.

Członkowie

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.
Wymiany	Zamiana dwóch obiektów możliwych do wywołania.
Docelowego	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.

Ax
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

Prawo
Obiekt funkcji do skopiowania.

Fx
Typ wywoływanego obiektu.

_Func
Obiekt wywoływany do opakowania.

Alloc
Typ alokatora.

Ax
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.

Prawo
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

Prawo
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

Udostępnij za pośrednictwem

function — Klasa

Składnia

Parametry

Uwagi

Członkowie

Konstruktory

Typedefs

Funkcje

Operatory

przypisywanie

Parametry

Uwagi

function

Parametry

Uwagi

Przykład

operator nieokreślony

Uwagi

Przykład

Operator()

Parametry

Uwagi

Przykład

operator =

Parametry

Uwagi

Przykład

Result_type

Uwagi

Przykład

swap

Parametry

Uwagi

Przykład

target

Parametry

Uwagi

Przykład

target_type

Uwagi

Przykład

Opinia

Opinia

Dodatkowe zasoby