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

function& operator=( const function& other );	(1)	(начиная с C++11)
function& operator=( function&& other );	(2)	(начиная с C++11)
function& operator=( std::nullptr_t ) noexcept;	(3)	(начиная с C++11)
template< class F > function& operator=( F&& f );	(4)	(начиная с C++11)
template< class F > function& operator=( std::reference_wrapper<F> f ) noexcept;	(5)	(начиная с C++11)

Назначает новую цель std::function.

1) Присваивает копию цели other, как если бы выполнялся вызов function(other).swap(*this);

2) Перемещает цель other в *this. other находится в допустимом состоянии с неопределённым значением.

3) Удаляет текущую цель. После вызова *this является пустым.

4) Устанавливает для цели *this вызываемый объект f, как если бы выполнялся вызов function(std::forward<F>(f)).swap(*this);. Этот оператор не участвует в разрешении перегрузки, если f не удовлетворяет требованиям Callable для типов аргументов Args... и типа возвращаемого значения R.

5) Устанавливает для цели *this копию f, как если бы выполнялся вызов function(f).swap(*this);

Параметры

other	-	другой объект `std::function`, цель которого копируется
f	-	вызываемый объект, которым инициализируется цель
Требования к типам
-`F` должен удовлетворять требованиям Callable.

Возвращаемое значение

*this

Примечания

Даже до удаления поддержки аллокаторов из std::function в C++17 в этих операторах присваивания используется аллокатор по умолчанию, а не аллокатор *this или other (см. предложение LWG 2386).

Пример

#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; // overload (1)
    assert(f1 != nullptr and f1(1) == 2);

    f1 = std::move(f2); // overload (2)
    assert(f1 != nullptr and f1(1) == 2);
    // f2 is in valid but unspecified state

    f1 = nullptr; // overload (3)
    assert(f1 == nullptr);

    f1 = inc; // overload (4)
    assert(f1 != nullptr and f1(1) == 2);

    f1 = [](int n) { return n + n; }; // overload (4)
    assert(f1 != nullptr and f1(2) == 4);

    std::reference_wrapper<int(int)> ref1 = std::ref(inc);
    f1 = ref1; // overload (5)
    assert(f1 != nullptr and f1(1) == 2);
}

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были ретроактивно применены к ранее опубликованным стандартам C++.

Отчёт об ошибке	Применён к	Опубликованное поведение	Корректное поведение
LWG 2132	C++11	перегрузка (4), принимающая объект Callable, могла быть неоднозначной	добавлены ограничения
LWG 2401	C++11	оператор присваивания (3) из `std::nullptr_t` не обязан был быть noexcept	обязан быть noexcept

См. также

operator=	заменяет или уничтожает цель (открытая функция-член `std::move_only_function`)
assign (удалена в C++17)	назначает новую цель (открытая функция-член)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility/functional/function/operator%3D