function (Clase)
Contenedor para un objeto al que se puede llamar.
Sintaxis
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
Tipo de función que se va a contener.
Ax
Función de asignador.
Comentarios
La plantilla de clase es un contenedor de llamadas cuya signatura de llamada es Ret(T1, T2, ..., TN). Úselo para incluir una variedad de objetos a los que se puede llamar en un contenedor uniforme.
Algunas funciones miembro toman un operando que designa el objeto de destino deseado. Puede especificar ese operando de varias maneras:
fn: el objeto fn al que se puede llamar; después de la llamada, el objeto function contiene una copia de fn.
fnref: el objeto al que se puede llamar denominado por fnref.get(); después de la llamada, el objeto function contiene una referencia a fnref.get().
right: el objeto al que se puede llamar, de haberlo, mantenido por el objeto functionright.
npc: un puntero nulo; después de la llamada, el objeto function está vacío
En todos los casos, INVOKE(f, t1, t2, ..., tN), donde f es el objeto al que se puede llamar y t1, t2, ..., tN son valores L de tipos T1, T2, ..., TN respectivamente, debe tener un formato correcto y, si Ret no es void, debe poder convertirse a Ret.
Un objeto function vacío no contiene ningún objeto al que se puede llamar ni ninguna referencia a un objeto al que se puede llamar.
Miembros
Constructores
| Nombre | Descripción |
|---|---|
| function | Crea un contenedor que está vacío o almacena un objeto al que se puede llamar de tipo arbitrario con una signatura fija. |
Typedefs
| Nombre | Descripción |
|---|---|
| result_type | El tipo de valor devuelto del objeto al que se puede llamar almacenado. |
Functions
| Nombre | Descripción |
|---|---|
| assign | Asigna un objeto al que se puede llamar a este objeto de función. |
| swap | Intercambia dos objetos a los que se puede llamar. |
| Destino | Comprueba si se puede llamar al objeto al que se puede llamar según lo especificado. |
| target_type | Obtiene información de tipo en el objeto al que se puede llamar. |
Operadores
| Nombre | Descripción |
|---|---|
| operator no especificado | Comprueba si existe un objeto al que se puede llamar almacenado. |
| operator() | Llama a un objeto al que se puede llamar. |
| operator= | Reemplaza el objeto al que se puede llamar almacenado. |
asignar
Asigna un objeto al 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 al que se puede llamar.
_Fnref
Un contenedor de referencia que contiene un objeto al que se puede llamar.
Ax
Un objeto de asignador.
Comentarios
Las funciones miembro reemplazan al callable object mantenido por *this por el objeto al que se puede llamar pasado como el operand. Ambas asignan almacenamiento con el objeto de asignador Ax.
function
Crea un contenedor que está vacío o almacena un objeto al que se puede llamar de tipo arbitrario con una signatura fija.
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
El objeto de función que se va a copiar.
Fx
El tipo del objeto al que se puede llamar.
_Func
El objeto al que se puede llamar que se va a encapsular.
Alloc
El tipo de asignador.
Ax
Asignador.
_Fnref
La referencia del objeto al que se puede llamar que se va a encapsular.
Comentarios
Los dos primeros constructores crean un objeto function vacío. Los siguientes tres constructores crean un objeto function que contiene el objeto al que se puede llamar que ha pasado como el operando. Los dos últimos constructores asignan almacenamiento con el objeto de asignador Ax.
Ejemplo
// 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 no especificado
Comprueba si existe un objeto al que se puede llamar almacenado.
operator unspecified();
Comentarios
El operador devuelve un valor que se puede convertir a bool con un valor true solo si el objeto no está vacío. Úselo para comprobar si el objeto está vacío.
Ejemplo
// 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()
Llama a un objeto al que se puede llamar.
result_type operator()(
T1 t1,
T2 t2, ...,
TN tN);
Parámetros
TN
Tipo del enésimo argumento de llamada.
tN
El enésimo argumento de llamada.
Comentarios
La función miembro devuelve INVOKE(fn, t1, t2, ..., tN, Ret), donde fn es el objeto de destino almacenado en *this. Úsela para llamar al objeto encapsulado al que se puede llamar.
Ejemplo
// 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=
Reemplaza el objeto al 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
El objeto de función que se va a copiar.
fn
El objeto al que se puede llamar que se va a encapsular.
fnref
La referencia del objeto al que se puede llamar que se va a encapsular.
Comentarios
Los operadores reemplazan el objeto al que se puede llamar mantenido por *this por el objeto al que se puede llamar pasado como el operando.
Ejemplo
// 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
El tipo de valor devuelto del objeto al que se puede llamar almacenado.
typedef Ret result_type;
Comentarios
Typedef es un sinónimo del tipo Ret en la signatura de llamada de la plantilla. Úselo para determinar el tipo de valor devuelto del objeto encapsulado al que se puede llamar.
Ejemplo
// 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
Intercambia dos objetos a los que se puede llamar.
void swap(function& right);
Parámetros
right
El objeto de función con el que intercambiar.
Comentarios
La función miembro intercambia los objetos de destino entre *this y right. Lo hace en tiempo constante y no inicia ninguna excepción.
Ejemplo
// 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
Comprueba si se puede llamar al objeto al que se puede llamar según lo especificado.
template <class Fty2>
Fty2 *target();
template <class Fty2>
const Fty2 *target() const;
Parámetros
Fty2
El tipo de objeto de destino al que se puede llamar que se va a comprobar.
Comentarios
Los tipos de argumento Fty2 deben poder llamarse para los tipos de argumento T1, T2, ..., TN y el tipo de valor devuelto Ret. Si target_type() == typeid(Fty2), la función de plantilla miembro devuelve la dirección del objeto de destino; de lo contrario, devuelve 0.
Se puede llamar a un tipo Fty2 para los tipos de argumento T1, T2, ..., TN y el tipo de valor devuelto Ret si, para los lvalues fn, t1, t2, ..., tN de tipos Fty2, T1, T2, ..., TN, respectivamente, INVOKE(fn, t1, t2, ..., tN) tiene el formato correcto y, si Ret no es void, no se puede convertir en Ret.
Ejemplo
// 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
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__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
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de