Espacios de nombres
Variantes
    Acciones
       
      C++
      Apoyo de compiladores
      Implementaciones independientes y albergadas
      Lenguaje
      Biblioteca estándar
      Encabezados de la biblioteca estándar
      Requisitos denominados
      Macros de prueba de característica (C++20)
      Biblioteca de apoyo del lenguaje
      Biblioteca de conceptos (C++20)
      Biblioteca de diagnósticos
      Biblioteca de gestión de memoria
      Biblioteca de metaprogramación (C++11)
      Biblioteca de servicios generales
      Biblioteca de contenedores
      Biblioteca de iteradores
      Biblioteca de rangos (C++20)
      Biblioteca de algoritmos
      Biblioteca de cadenas
      Biblioteca de procesamiento de texto
      Biblioteca numérica
      Biblioteca de fecha y hora
      Biblioteca de entrada/salida
      Biblioteca del sistema de archivos (C++17)
      Biblioteca de apoyo de concurrencia (C++11)
      Biblioteca de apoyo de ejecución (C++26)
      Especificaciones técnicas
      Índice de símbolos
      Bibliotecas externas
       
      Requisitos denominados de C++
      Números aleatorios
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Concurrencia
      (C++11)
      (C++11)
      (C++11)
      (C++14)
      (C++14)
      (C++11)
      (C++11)
      (C++17)
      (C++14)
      Rangos
      (C++20)
      (C++20)
      Vista multidimensional
      (C++23)
      (C++23)
      (C++23)
      Otros

       

      Un tipo Callable (invocable) es un tipo para el que las operaciones INVOKE e INVOKE<R> (p. ej., usada por std::function, std::bind, y std::thread::thread) son aplicables.

      INVOKE se puede realizar explícitamente utilizando la función de biblioteca std::invoke.

      		(desde C++17)

      INVOKE<R> se puede realizar explícitamente utilizando la función de biblioteca std::invoke_r.

      		(desde C++23)

      Requisitos

      El tipo T satisface a Callable si

      Dados

      • f, un objeto de tipo T,
      • ArgTypes, una lista adecuada de tipos argumento, y
      • R, un valor de retorno adecuado.

      Las siguientes expresiones deben ser válidas:

      Expresión Requisitos
      INVOKE<R>(f, std::declval<ArgTypes>()...) La expresión está bien formada en un contexto no evaluado

      Notas

      Los punteros a datos miembro son Callable, aun cuando no se hagan llamadas a función.

      Biblioteca estándar

      Además, los siguientes servicios de la biblioteca estándar aceptan cualquier tipo Callable (no solo FunctionObject):

      (C++11)
      		 Envuelve un objeto que puede ser llamado a cualquier tipo con la signatura de llamada a función especificada.
      (plantilla de clase)
      (C++23)
      		 Envuelve un objeto invocable de cualquier tipo con la signatura de llamada a función especificada.
      (plantilla de clase)
      (C++26)
      		 envoltura copiable de cualquier copia de objeto construible y llamable que admita calificadores en una firma de llamada determinada
      (plantilla de clase)
      (C++26)
      		 envolvente no propietaria de cualquier objeto invocable
      (plantilla de clase)
      (C++11)
      		 Vincula uno o más argumentos a un objeto función.
      (plantilla de función)
      (C++20)(C++23)
      		 Vincula un número variable de argumentos, en orden, a un objeto función.
      (plantilla de función)
      (C++11)
      		 Envoltorio de referencia CopyConstructible y CopyAssignable.
      (plantilla de clase)
      (C++11)
      		 Deduce el tipo de retorno de una expresión de llamada a la función.
      (plantilla de clase)
      (C++11)
      		 Gestiona un hilo/subproceso independiente.
      (clase)
      (C++20)
      		 std::thread con soporte para unión y cancelación automática.
      (clase)
      (C++11)
      		 Invoca una función una sola vez inclusive si se llama desde varios hilos.
      (plantilla de función)
      (C++11)
      		 Ejecuta una función asíncronamente (posiblemente en un nuevo hilo) y devuelve un std::future que contendrá el resultado.
      (plantilla de función)
      (C++11)
      		 Empaqueta una función para almacenar su valor de retorno para la recuperación asíncrona.
      (plantilla de clase)


      Véase también

      (C++17)
      		 Comprueba si un tipo puede invocarse (como si lo fuera por std::invoke) con el número de argumentos dado.
      (plantilla de clase)
      (C++20)
      		 especifica que un tipo invocable puede ser invocado con un conjunto dado de tipos de argumentos
      (concepto)
      (C++17)(C++23)
      		 Invoca cualquier objeto Callable con los argumentos dados y la posibilidad de especificar el tipo de retorno. (desde C++23)
      (plantilla de función)