std::function<R(Args...)>::operator=
Depuis fr.cppreference.net
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) Assigne une copie de la cible de
other, comme si en exécutant function(other).swap(*this);2) Déplace la cible de
other vers *this. other est dans un état valide avec une valeur non spécifiée.3) Abandonne la cible courante.
*this est vide après l'appel.4) Définit la cible de
*this sur l'élément appelable f, comme si 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 Appelable pour les types d'arguments Args... et le type de retour R.5) Définit la cible de
*this sur une copie de f, comme si en exécutant function(f).swap(*this);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) |