Espacios de nombres
Variantes
Acciones

Requisitos denominados de C++: FunctionObject

De cppreference.com
< cpp‎ | named req
 
 
Requisitos denominados de C++
Números aleatorios
Concurrencia
(C++11)
(C++11)
Rangos
Vista multidimensional
Otros

 

Un tipo FunctionObject es el tipo de un objeto que puede usarse a la izquierda del operador de llamada a función.

Contenido

[editar] Requisitos

El tipo T satisface a FunctionObject si

Dados

  • f, un valor de tipo T o const T, y
  • args, una lista de argumentos adecuada, que puede estar vacía.

Las siguientes expresiones deben ser válidas:

Expresión Requisitos
f(args) Realiza una llamada a función.

[editar] Notas

Las funciones y referencias a función no son tipos objeto función, pero pueden usarse dondequiera que se esperen tipos objeto función debido a la conversión implícita de función a puntero.

[editar] Biblioteca estándar

[editar] Ejemplo

Muestra diferentes tipos de objetos de función.

#include <functional>
#include <iostream>
 
void foo(int x) { std::cout << "foo(" << x << ")\n"; }
void bar(int x) { std::cout << "bar(" << x << ")\n"; }
 
int main()
{
    void(*fp)(int) = foo;
    fp(1); // llama a foo usando el puntero a función
 
    std::invoke(fp, 2); // todos los tipos FunctionObject son Callable
 
    auto fn = std::function(foo); // véase también el resto de <functional>
    fn(3);
    fn.operator()(3); // el mismo efecto que fn(3)
 
    struct S
    {
        void operator()(int x) const { std::cout << "S::operator(" << x << ")\n"; }
    } s;
 
    s(4); // llama a s.operator()
    s.operator()(4); // lo mismo que s(4)
 
    auto lam = [](int x) { std::cout << "lambda(" << x << ")\n"; };
    lam(5); // llama al lambda
    lam.operator()(5); // lo mismo que lam(5)
 
    struct T
    {
        using FP = void (*)(int);
        operator FP() const { return bar; }
    } t;
 
    t(6); // se convierte t en un puntero a función
    static_cast<void (*)(int)>(t)(6); // lo mismo que t(6)
    t.operator T::FP()(6); // lo mismo que t(6) 
}

Salida:

foo(1)
foo(2)
foo(3)
foo(3)
S::operator(4)
S::operator(4)
lambda(5)
lambda(5)
bar(6)
bar(6)
bar(6)

[editar] Véase también

Un tipo para el cual se define la operación de invocación.
(requerimiento denominado)