function (Clase)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

Contenedor para un objeto que se puede llamar.

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>  
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
Tipo de función que se va a contener.

_Ax
La función de asignador.

La clase de plantilla es un contenedor de llamadas cuya signatura de llamada es Ret(T1, T2, ..., TN). Usarlo para incluir una variedad de objetos que se puede llamar en un contenedor uniforme.

Algunas funciones de miembro toman un operando que designa el objeto de destino deseado. Puede especificar este tipo de operando de varias maneras:

fn--el objeto que se puede llamar fn; después de la llamada la function objeto contiene una copia defn

fnref--el objeto que se puede llamar con el nombre fnref.get(); después de la llamada la function objeto contiene una referencia afnref.get()

right--el objeto que se puede llamar, si los hay, mantenidos por la function objetoright

npc--un puntero nulo; Después de la llamada la function objeto está vacío

En todos los casos, INVOKE(f, t1, t2, ..., tN), donde f es el objeto que se puede llamar y t1, t2, ..., tN son valores l de tipos T1, T2, ..., TN respectivamente, debe ser correcto y, si Ret no es void, puede convertir a Ret.

Una cadena vacía function objeto no tiene un objeto que se puede llamar o una referencia a un objeto que se puede llamar.

Constructores

Function::FunctionCrea un contenedor que está vacío o que almacena un objeto de tipo arbitrario con una firma fija que se puede llamar.

Definiciones de tipo

Function::result_typeEl tipo de valor devuelto del objeto que se puede llamar almacenado.

Funciones miembro

Function::AssignAsigna un objeto que se puede llamar a este objeto de función.
Function::swapIntercambia dos objetos que se puede llamar.
Function::targetComprueba si almacena el objeto invocable es invocable según lo especificado.
Function::target_typeObtiene información de tipo en el objeto al que se puede llamar.

Operadores

Function::operator no especificadoComprueba si existe el objeto que se puede llamar almacenado.
función::operator()Llama a un objeto que se puede llamar.
Function::operator =Reemplaza el objeto que se puede llamar almacenado.

Encabezado:<>>

Espacio de nombres: std

Asigna un objeto que se puede llamar a este objeto de función.

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
Un objeto que se puede llamar.

_Fnref
Un contenedor de referencia que contiene un objeto que se puede llamar.

_Ax
Un objeto de asignador.

Comentarios

Las funciones miembro cada reemplazar la callable object mantenidos por *this con el objeto que se puede llamar pasado como el operand. Ambos asignación almacenamiento con el objeto de asignador _Ax.

Crea un contenedor que está vacío o que almacena un objeto de tipo arbitrario con una firma fija que se puede llamar.

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

right
Objeto de función que se va a copiar.

FX
El tipo del objeto que se puede llamar.

_Func
El objeto que se puede llamar para ajustar.

Asignación
El tipo de asignador.

_Ax
Asignador.

_Fnref
La referencia de objeto que se puede llamar a ajustar.

Comentarios

Los dos primeros constructores construcción vacía function objeto. Los siguientes tres constructores crean un function pasa el objeto que contiene el objeto que se puede llamar como el operando. Los dos últimos constructores asignación almacenamiento con el asignador _Ax del objeto.

Ejemplo

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

Comprueba si existe el objeto que se puede llamar almacenado.

''' operador unspecified();

  
### Remarks  
 The operator returns a value that is convertible to `bool` with a true value only if the object is not empty. You use it to test whether the object is empty.  
  
### Example  
  

std_tr1__functional__function_operator_bool.cpp
compilar con: / EHsc
#incluir
#incluir

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

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

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

return (0);   
}  

  
```Output  
not empty == false  
not empty == true  

Llama a un objeto que se puede llamar.

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

Parámetros

TN
El tipo del enésimo llame al argumento.

tN
El argumento enésimo llamada.

Comentarios

La función miembro devuelve INVOKE(fn, t1, t2, ..., tN, Ret), donde fn está almacenado en el objeto de destino *this. Utilizarlo para llamar al objeto ajustado que se puede llamar.

Ejemplo

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

Reemplaza el objeto que se puede llamar almacenado.

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
Una constante de puntero nulo.

right
Objeto de función que se va a copiar.

fn
El objeto que se puede llamar para ajustar.

fnref
La referencia de objeto que se puede llamar a ajustar.

Comentarios

Los operadores reemplazar el objeto que se puede llamar almacenado por *this con el objeto que se puede llamar se pasa como el operando.

Ejemplo

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

El tipo de valor devuelto del objeto que se puede llamar almacenado.

typedef Ret result_type;  

Comentarios

La definición de tipo es un sinónimo del tipo Ret de firma de llamada de la plantilla. Utilizarlo para determinar el tipo de valor devuelto del objeto ajustado que se puede llamar.

Ejemplo

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

Intercambia dos objetos que se puede llamar.

void swap(function& right);

Parámetros

right
Intercambiar con el objeto de función.

Comentarios

La función miembro intercambia entre los objetos de destino *this y right. Lo hace en tiempo constante y no inicia ninguna excepción.

Ejemplo

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

Comprueba si almacena el objeto invocable es invocable según lo especificado.

template <class Fty2>  
Fty2 *target();

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

Parámetros

Fty2
El tipo de objeto que se puede llamar de destino para probar.

Comentarios

El tipo Fty2 debe ser invocable para los tipos de argumento T1, T2, ..., TN y el tipo devuelto Ret. Si target_type() == typeid(Fty2), la función miembro de la plantilla devuelve la dirección del objeto de destino; de lo contrario, devuelve 0.

Un tipo Fty2 sea accesible para los tipos de argumento T1, T2, ..., TN y el tipo devuelto Ret if para valores l fn, t1, t2, ..., tN de tipos Fty2, T1, T2, ..., TN, respectivamente, INVOKE(fn, t1, t2, ..., tN) es correcto y, si Ret no void, puede convertir a Ret.

Ejemplo

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

Obtiene información de tipo en el objeto al que se puede llamar.

const std::type_info& target_type() const;

Comentarios

La función miembro devuelve typeid(void) si *this está vacío; de lo contrario, devuelve typeid(T), donde T es el tipo del objeto de destino.

Ejemplo

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

mem_fn (función)
reference_wrapper (clase)

Mostrar: