Namespaces
Variants

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

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 & operator = ( const function & other ) ;
(1) (depuis C++11)
function & operator = ( function && other ) ;
(2) (depuis C++11)
function & operator = ( std:: nullptr_t ) noexcept ;
(3) (depuis C++11)
template < class F >
function & operator = ( F && f ) ;
(4) (depuis C++11)
template < class F >
function & operator = ( std:: reference_wrapper < F > f ) noexcept ;
(5) (depuis C++11)

Assigne une nouvelle cible à std::function .

1) Attribue une copie de target de other , comme en exécutant function ( other ) . swap ( * this ) ;
2) Déplace la cible de other vers * this . other se trouve dans un état valide avec une valeur non spécifiée.
3) Abandonne la cible actuelle. * this est vide après l'appel.
4) Définit la cible de * this comme étant l'objet appelable f , comme en exécutant function ( std:: forward < F > ( f ) ) . swap ( * this ) ; . Cet opérateur ne participe pas à la résolution de surcharge sauf si f est Callable pour les types d'arguments Args... et le type de retour R .
5) Définit la cible de * this comme une copie de f , comme si on exécutait function ( f ) . swap ( * this ) ;

Table des matières

Paramètres

other - autre objet std::function à copier la cible de
f - un appelable pour initialiser la cible avec
Exigences de type
-
F doit satisfaire aux exigences de Callable .

Valeur de retour

* this

Notes

Même avant que la prise en charge des allocateurs ne soit supprimée de std::function en C++17, ces opérateurs d'affectation utilisent l'allocateur par défaut plutôt que l'allocateur de * this ou l'allocateur de other (voir LWG issue 2386 ).

Exemple

Exécuter ce code 
#include <cassert>
#include <functional>
#include <utility>
int inc(int n) { return n + 1; }
int main()
{
    std::function<int(int)> f1;
    std::function<int(int)> f2(inc);
    assert(f1 == nullptr and f2 != nullptr);
    f1 = f2; // surcharge (1)
    assert(f1 != nullptr and f1(1) == 2);
    f1 = std::move(f2); // surcharge (2)
    assert(f1 != nullptr and f1(1) == 2);
    // f2 est dans un état valide mais non spécifié
    f1 = nullptr; // surcharge (3)
    assert(f1 == nullptr);
    f1 = inc; // surcharge (4)
    assert(f1 != nullptr and f1(1) == 2);
    f1 = [](int n) { return n + n; }; // surcharge (4)
    assert(f1 != nullptr and f1(2) == 4);
    std::reference_wrapper<int(int)> ref1 = std::ref(inc);
    f1 = ref1; // surcharge (5)
    assert(f1 != nullptr and f1(1) == 2);
}

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 Applicable à Comportement publié Comportement corrigé
LWG 2132 C++11 la surcharge ( 4 ) prenant un objet Callable pouvait être ambiguë contrainte
LWG 2401 C++11 l'opérateur d'affectation ( 3 ) depuis std::nullptr_t n'était pas requis d'être noexcept requis

Voir aussi

remplace ou détruit la cible
(fonction membre publique de std::move_only_function )
(supprimée en C++17)
assigne une nouvelle cible
(fonction membre publique)