function – třída

Článek
10/12/2023

Obálka pro volatelný objekt

Syntaxe

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 funkce, který chcete zabalit.

Ax
Funkce alokátoru.

Poznámky

Šablona třídy je obálka volání, jejíž podpis volání je Ret(T1, T2, ..., TN). Slouží k uzavření různých volatelných objektů do uniformní obálky.

Některé členské funkce přebírají operand, který pojmenuje požadovaný cílový objekt. Takový operand můžete zadat několika způsoby:

fn: Volatelný objekt fn; po volání function objekt obsahuje kopii fn

fnref: Volatelný objekt s názvem fnref.get(); po volání function objekt obsahuje odkaz na fnref.get()

right: Volatelný objekt, pokud existuje, uchovávaný objektem functionright

npc: Ukazatel null; po volání objektu function je prázdný.

Ve všech případech , INVOKE(f, t1, t2, ..., tN)kde f je volatelný objekt a t1, t2, ..., tN jsou lvalues typů T1, T2, ..., TN v uvedeném pořadí, musí být dobře formátován a pokud Ret není void, konvertibilní na Ret.

Prázdný function objekt neobsahuje volatelný objekt ani odkaz na volatelný objekt.

Členové

Konstruktory

Jméno	popis
Funkce	Vytvoří obálku, která je prázdná nebo uloží volatelný objekt libovolného typu s pevným podpisem.

Typedefs

Jméno	popis
result_type	Návratový typ uloženého volatelného objektu.

Funkce

Jméno	popis
Přiřadit	Přiřadí volatelný objekt k tomuto objektu funkce.
Swap	Prohodí dva volatelné objekty.
Cíl	Testuje, zda je uložený volatelný objekt volatelný podle zadaného.
target_type	Získá informace o typu volatelného objektu.

Operátory

Jméno	popis
operátor není zadaný.	Testuje, zda uložený volatelný objekt existuje.
operator()	Volá volatelný objekt.
operator=	Nahradí uložený volatelný objekt.

přiřadit

Přiřadí volatelný objekt k tomuto objektu funkce.

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
Volatelný objekt.

_Fnref
Obálka odkazu, která obsahuje volatelný objekt.

Ax
Objekt alokátoru.

Poznámky

Členské funkce každý nahradí callable object držení *this volatelným objektem předaným jako operand. Oba přidělují úložiště s objektem alokátoru Ax.

function

Vytvoří obálku, která je prázdná nebo uloží volatelný objekt libovolného typu s pevným 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

Právo
Objekt funkce, který chcete zkopírovat.

Fx
Typ volatelného objektu.

_Func
Volatelný objekt, který se má zalamovat.

Alloc
Typ alokátoru.

Ax
Alokátor.

_Fnref
Odkaz na volatelný objekt, který se má zalamovat.

Poznámky

První dva konstruktory vytvoří prázdný function objekt. Další tři konstruktory vytvoří function objekt, který obsahuje volatelný objekt předaný jako operand. Poslední dva konstruktory přidělují úložiště pomocí objektu alokátoru Ax.

Příklad

// 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).

operátor není zadaný.

Testuje, zda uložený volatelný objekt existuje.

operator unspecified();

Poznámky

Operátor vrátí hodnotu, na kterou se konvertibilní bool hodnota s hodnotou true pouze v případě, že objekt není prázdný. Použijete ho k otestování, jestli je objekt prázdný.

Příklad

// 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()

Volá volatelný objekt.

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

Parametry

TN
Typ argumentu Nth call.

Tn
Nth call argument.

Poznámky

Člen funkce vrátí INVOKE(fn, t1, t2, ..., tN, Ret), kde fn je cílový objekt uložený v *this. Použijete ho k volání zalomeného volatelného objektu.

Příklad

// 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=

Nahradí uložený volatelný objekt.

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
Konstanta ukazatele null.

Právo
Objekt funkce, který chcete zkopírovat.

Fn
Volatelný objekt, který se má zalamovat.

fnref
Odkaz na volatelný objekt, který se má zalamovat.

Poznámky

Operátory každý nahradí volatelný objekt uchovávaný volatelným objektem předaným *this jako operand.

Příklad

// 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

Návratový typ uloženého volatelného objektu.

typedef Ret result_type;

Poznámky

Typedef je synonymem pro typ Ret v podpisu volání šablony. Použijete ho k určení návratového typu zalomeného volatelného objektu.

Příklad

// 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

Prohodí dva volatelné objekty.

void swap(function& right);

Parametry

Právo
Objekt funkce, se kterým se má prohodit.

Poznámky

Členová funkce prohodí cílové objekty mezi *this a vpravo. Provede to v konstantním čase a nevyvolá žádné výjimky.

Příklad

// 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

Testuje, zda je uložený volatelný objekt volatelný podle zadaného.

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

Parametry

Fty2
Cílový typ volatelného objektu k otestování.

Poznámky

Typ Fty2 musí být volatelný pro typy T1, T2, ..., TN argumentů a návratový typ Ret. Pokud target_type() == typeid(Fty2)funkce členské šablony vrátí adresu cílového objektu, v opačném případě vrátí hodnotu 0.

Typ Fty2 je volatelný pro typy T1, T2, ..., TN argumentů a návratový typ Ret , pokud je pro lvalues fn, t1, t2, ..., tN typů Fty2, T1, T2, ..., TN, v uvedeném pořadí, INVOKE(fn, t1, t2, ..., tN) dobře formátován a pokud Ret není void, konvertibilní na Ret.

Příklad

// 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

Získá informace o typu volatelného objektu.

const std::type_info& target_type() const;

Poznámky

Členová funkce vrátí typeid(void) , pokud *this je prázdná, jinak vrátí typeid(T), kde T je typ cílového objektu.

Příklad

// 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

Sdílet prostřednictvím

function – třída

Syntaxe

Parametry

Poznámky

Členové

Konstruktory

Typedefs

Funkce

Operátory

přiřadit

Parametry

Poznámky

function

Parametry

Poznámky

Příklad

operátor není zadaný.

Poznámky

Příklad

operator()

Parametry

Poznámky

Příklad

operator=

Parametry

Poznámky

Příklad

result_type

Poznámky

Příklad

swap

Parametry

Poznámky

Příklad

target

Parametry

Poznámky

Příklad

target_type

Poznámky

Příklad

Váš názor

Váš názor

Další materiály