std::function<R(Args...)>::operator=
De es.cppreference.net
function& operator=( const function& other );
|
(1) | (desde C++11) |
function& operator=( function&& other );
|
(2) | (desde C++11) |
function& operator=( std::nullptr_t ) noexcept;
|
(3) | (desde C++11) |
template< class F >
function& operator=( F&& f );
|
(4) | (desde C++11) |
template< class F >
function& operator=( std::reference_wrapper<F> f ) noexcept;
|
(5) | (desde C++11) |
Asigna un nuevo destino a std::function.
1) Asigna una copia del destino de
other, como si se ejecutara function(other).swap(*this);2) Mueve el destino de
other a *this. other está en un estado válido con un valor no especificado.3) Descarta el destino actual.
*this está vacío después de la llamada.4) Establece el destino de
*this al invocable f, como si se ejecutara function(std::forward<F>(f)).swap(*this);. Este operador no participa en la resolución de sobrecarga a menos que f sea Invocable para los tipos de argumento Args... y el tipo de retorno R.5) Establece el destino de
*this a una copia de f, como si se ejecutara function(f).swap(*this);Parámetros
| otro | - |
otro objeto
std::function
para copiar el destino de
|
| f | - | un invocable para inicializar el target con |
| Requisitos de tipo | ||
-
F
debe cumplir con los requisitos de
Callable
.
|
||
Valor de retorno
* this
Notas
Incluso antes de que se eliminara el soporte de allocator de
std::function
en C++17, estos operadores de asignación utilizan el allocator por defecto en lugar del allocator de
*
this
o del allocator de
other
(consulte
LWG issue 2386
).
Ejemplo
Ejecutar este código
#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; // sobrecarga (1) assert(f1 != nullptr and f1(1) == 2); f1 = std::move(f2); // sobrecarga (2) assert(f1 != nullptr and f1(1) == 2); // f2 está en un estado válido pero no especificado f1 = nullptr; // sobrecarga (3) assert(f1 == nullptr); f1 = inc; // sobrecarga (4) assert(f1 != nullptr and f1(1) == 2); f1 = [](int n) { return n + n; }; // sobrecarga (4) assert(f1 != nullptr and f1(2) == 4); std::reference_wrapper<int(int)> ref1 = std::ref(inc); f1 = ref1; // sobrecarga (5) assert(f1 != nullptr and f1(1) == 2); }
Informes de defectos
Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.
| DR | Aplicado a | Comportamiento publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 2132 | C++11 | la sobrecarga ( 4 ) que toma un objeto Callable podría ser ambigua | restringida |
| LWG 2401 | C++11 |
el operador de asignación
(
3
)
desde
std::nullptr_t
no requería ser noexcept
|
requerido |
Véase también
|
reemplaza o destruye el objetivo
(función miembro pública de
std::move_only_function
)
|
|
|
(eliminada en C++17)
|
asigna un nuevo objetivo
(función miembro pública) |