Namespaces
Variants

std::function<R(Args...)>:: function

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Old binders and adaptors
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
std::function
function ( ) noexcept ;
(1) (depuis C++11)
function ( std:: nullptr_t ) noexcept ;
(2) (depuis C++11)
function ( const function & other ) ;
(3) (depuis C++11)
(4)
function ( function && other ) ;
(depuis C++11)
(jusqu'à C++20)
function ( function && other ) noexcept ;
(depuis C++20)
template < class F >
function ( F && f ) ;
(5) (depuis C++11)
template < class Alloc >
function ( std:: allocator_arg_t , const Alloc & alloc ) noexcept ;
(6) (depuis C++11)
(supprimé dans C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

std:: nullptr_t ) noexcept ;
(7) (depuis C++11)
(supprimé dans C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

const function & other ) ;
(8) (depuis C++11)
(supprimé dans C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

function && other ) ;
(9) (depuis C++11)
(supprimé dans C++17)
template < class F, class Alloc >
function ( std:: allocator_arg_t , const Alloc & alloc, F f ) ;
(10) (depuis C++11)
(supprimé dans C++17)

Construit un std::function à partir de diverses sources.

1,2) Crée une fonction std::function vide.
3) Copie la cible de other vers la cible de * this .
Si other est vide, * this sera également vide immédiatement après l'appel.
4) Déplace la cible de other vers la cible de * this .
Si other est vide, * this sera également vide immédiatement après l'appel.
other se trouve dans un état valide mais non spécifié immédiatement après l'appel.
5) Initialise la cible avec std:: forward < F > ( f ) . La cible est de type std:: decay < F > :: type .
Si f est un pointeur nul vers une fonction, un pointeur nul vers un membre, ou une valeur vide d'une spécialisation de std::function , * this sera vide immédiatement après l'appel.
Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :
(depuis C++23)
  • Une lvalue de type std:: decay < F > :: type est appelable pour les types d'arguments Args... et le type de retour R .

Si std:: is_copy_constructible_v < std:: decay_t < F >> ou std:: is_constructible_v < std:: decay_t < F > , F > est false , le programme est mal formé.

(depuis C++23)
Si F n'est pas CopyConstructible , le comportement est indéfini.
6-10) Identique à (1-5) sauf que alloc est utilisé pour allouer la mémoire pour toute structure de données interne que le std::function pourrait utiliser.

Lorsque la cible est un pointeur de fonction ou un std::reference_wrapper , l'optimisation des petits objets est garantie, c'est-à-dire que ces cibles sont toujours stockées directement à l'intérieur de l'objet std::function , aucune allocation dynamique n'a lieu. Les autres objets volumineux peuvent être construits dans un stockage alloué dynamiquement et accessibles par l'objet std::function via un pointeur.

Table des matières

Paramètres

other - l'objet fonction utilisé pour initialiser * this
f - un objet appelable utilisé pour initialiser * this
alloc - un Allocator utilisé pour l'allocation de mémoire interne
Exigences de type
-
Alloc doit satisfaire aux exigences de Allocator .

Exceptions

3,8,9) Ne lance pas d'exception si other a pour cible un pointeur de fonction ou un std::reference_wrapper , sinon peut lancer std::bad_alloc ou toute exception levée par le constructeur utilisé pour copier ou déplacer l'objet appelable stocké.
4) Ne lance pas d'exception si other a pour cible un pointeur de fonction ou un std::reference_wrapper , sinon peut lancer std::bad_alloc ou toute exception levée par le constructeur utilisé pour copier ou déplacer l'objet appelable stocké.
(until C++20)
5,10) Ne lance pas d'exception si f est un pointeur de fonction ou un std::reference_wrapper , sinon peut lancer std::bad_alloc ou toute exception levée par le constructeur de copie de l'objet appelable stocké.

Notes

std::function 's prise en charge des allocateurs était mal spécifiée et mise en œuvre de manière incohérente. Certaines implémentations ne fournissent pas du tout les surcharges ( 6-10 ) , certaines fournissent les surcharges mais ignorent l'argument d'allocateur fourni, et certaines fournissent les surcharges et utilisent l'allocateur fourni pour la construction mais pas lorsque le std::function est réaffecté. En conséquence, la prise en charge des allocateurs a été supprimée en C++17.

Exemple

Exécuter ce code 
#include <functional>
#include <iostream>
#include <utility>
void print_num(int i) { std::cout << "print_num(" << i << ")\n"; }
int main()
{
    std::function<void(int)> func1; // (1) constructeur vide
    try
    {
        func1(333 << 1);
    }
    catch (const std::bad_function_call& ex)
    {
        std::cout << "1) " << ex.what() << '\n';
    }
    std::function<void(int)> func2{nullptr}; // (2) constructeur vide
    try
    {
        func1(222 * 3);
    }
    catch (const std::bad_function_call& ex)
    {
        std::cout << "2) " << ex.what() << '\n';
    }
    func1 = print_num; // initialise func1 en utilisant l'opérateur d'affectation
    std::function<void(int)> func3{func1}; // (3) constructeur de copie
    func3(33);
    std::function<void(int)> func4{std::move(func3)}; // (4) constructeur de déplacement,
                                                      // func3 dans un état non spécifié
    func4(44);
    std::function<void(int)> func5{print_num}; // (5) constructeur avec fonction
    func5(55);
    // (5) constructeur avec lambda
    std::function<void(int)> func6([](int i) { std::cout << "lambda(" << i << ")\n"; });
    func6(66);
}

Sortie possible : 

1) bad_function_call
2) bad_function_call
print_num(33)
print_num(44)
print_num(55)
lambda(66)

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2132 C++11 les surcharges ( 5,10 ) pouvaient être ambiguës contraintes
LWG 2774 C++11 ( 5,10 ) effectuait un déplacement supplémentaire éliminé

Voir aussi

construit un nouvel objet std::move_only_function
(fonction membre publique de std::move_only_function )