Classe function

Wrapper para um objeto que pode ser chamado.

Sintaxe

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;
};

Parâmetros

Fty
O tipo de função a ser encapsulada.

_Ax
A função do alocador.

Comentários

O modelo de classe é um wrapper de chamada cuja assinatura de chamada é Ret(T1, T2, ..., TN). Você pode usá-lo para circunscrever uma variedade de objetos resgatáveis em um wrapper uniforme.

Algumas funções membro usam um operando que nomeia o objeto de destino desejado. É possível especificar esse operando de várias maneiras:

fn: o objeto que pode ser chamado fn; após a chamada, o objeto function mantém uma cópia de fn

fnref: o objeto que pode ser chamado nomeado por fnref.get(); após a chamada, o objeto function mantém uma referência a fnref.get()

right: o objeto que pode ser chamado, se houver, mantido pelo objeto function right

npc: um ponteiro nulo; após a chamada, o objeto function fica vazio

Em todos os casos, INVOKE(f, t1, t2, ..., tN), em que f é o objeto que pode ser chamado e t1, t2, ..., tN são lvalues dos tipos T1, T2, ..., TN, respectivamente, precisa ser bem formado e, se Ret não for nulo, conversível em Ret.

Um objeto function vazio não tem um objeto que pode ser chamado ou uma referência a um objeto que pode ser chamado.

Membros

Construtores

Nome	Descrição
function	Constrói um wrapper que é vazio ou armazena um objeto que pode ser chamado, de tipo arbitrário com uma assinatura fixa.

Typedefs

Nome	Descrição
result_type	O tipo retornado do objeto que pode ser chamado armazenado.

Funções

Nome	Descrição
assign	Atribui um objeto que pode ser chamado a esse objeto de função.
troca	Troca dois objetos resgatáveis.
destino	Testa se o objeto pode ser chamado conforme especificado.
target_type	Obtém informações de tipo sobre o objeto que pode ser chamado.

Operadores

Nome	Descrição
operador não especificado	Testa se o objeto que pode ser chamado armazenado existe.
operador()	Chama um objeto que pode ser chamado.
operator=	Substitui o objeto que pode ser chamado armazenado.

assign

Atribui um objeto que pode ser chamado a esse objeto de função.

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);

Parâmetros

_Func
Um objeto que pode ser chamado.

_Fnref
Um wrapper de referência que contém um objeto que pode ser chamado.

_Ax
Um objeto alocador.

Comentários

As funções membro substituem o callable object mantido por *this pelo objeto que pode ser chamado passado como o operand. Ambas alocam o armazenamento com o objeto de alocador Ax.

função

Constrói um wrapper que é vazio ou armazena um objeto que pode ser chamado, de tipo arbitrário com uma assinatura fixa.

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);

Parâmetros

direita
O objeto de função a ser copiado.

Fx
O tipo do objeto que pode ser chamado.

_Func
O objeto que pode ser chamado a ser encapsulado.

Alloc
O tipo do alocador.

_Ax
O alocador.

_Fnref
A referência do objeto que pode ser chamado a ser encapsulado.

Comentários

Os dois primeiros construtores constroem um objeto function vazio. Os próximos três construtores constroem um objeto function que contém o objeto que pode ser chamado passado como o operando. Os últimos dois construtores alocam o armazenamento com o objeto de alocador Ax.

Exemplo

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

operador não especificado

Testa se o objeto que pode ser chamado armazenado existe.

operator unspecified();

Comentários

O operador retornará um valor conversível em bool com um valor true somente se o objeto não estiver vazio. Você pode usá-lo para testar se o objeto está vazio.

Exemplo

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

operador()

Chama um objeto que pode ser chamado.

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

Parâmetros

TN
O tipo do enésimo argumento de chamada.

tN
O enésimo argumento de chamada.

Comentários

A função membro retorna INVOKE(fn, t1, t2, ..., tN, Ret), em que fn é o objeto de destino armazenado em *this. Você pode usá-lo para chamar o objeto que pode ser chamado encapsulado.

Exemplo

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

Substitui o objeto que pode ser chamado armazenado.

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);

Parâmetros

npc
Uma constante de ponteiro nulo.

direita
O objeto de função a ser copiado.

fn
O objeto que pode ser chamado a ser encapsulado.

fnref
A referência do objeto que pode ser chamado a ser encapsulado.

Comentários

Os operadores substituem o objeto que pode ser chamado mantido por *this pelo objeto que pode ser chamado passado como o operando.

Exemplo

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

O tipo retornado do objeto que pode ser chamado armazenado.

typedef Ret result_type;

Comentários

O typedef é um sinônimo do tipo de Ret na assinatura de chamada do modelo. Você pode usá-lo para determinar o tipo retornado do objeto que pode ser chamado encapsulado.

Exemplo

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

troca

Troca dois objetos resgatáveis.

void swap(function& right);

Parâmetros

direita
O objeto de função com o qual será feita a troca.

Comentários

A função membro troca os objetos de destino entre *this e right. Ela faz isso em um horário constante e não gera exceções.

Exemplo

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

destino

Testa se o objeto pode ser chamado conforme especificado.

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

Parâmetros

Fty2
O tipo de objeto que pode ser chamado de destino a ser testado.

Comentários

O tipo Fty2 precisa ser que pode ser chamado para os tipos de argumento T1, T2, ..., TN e o tipo retornado Ret. Se target_type() == typeid(Fty2), a função modelo membro retornará o endereço do objeto de destino; caso contrário, retornará 0.

Um tipo Fty2 pode ser chamado para os tipos de argumento T1, T2, ..., TN e o tipo retornado Ret se, para lvalues fn, t1, t2, ..., tN dos tipos Fty2, T1, T2, ..., TN, respectivamente, INVOKE(fn, t1, t2, ..., tN) for bem formado e, se Ret não for void, conversível em Ret.

Exemplo

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

Obtém informações de tipo sobre o objeto que pode ser chamado.

const std::type_info& target_type() const;

Comentários

A função membro retorna typeid(void) se *this estiver vazio, caso contrário, ela retorna typeid(T), em que T é o tipo de objeto de destino.

Exemplo

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