Просмотр кода страницы cpp/utility/functional/bind

У вас нет прав на выполнение действия «редактирование этой страницы» по следующей причине:
Запрошенное действие могут выполнять участники одной из следующих групп: Участники, Администраторы.
Вы можете просмотреть и скопировать исходный код этой страницы.
{{cpp/title|bind}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev multi | num=1 | since1=c++11 | dcl1=
template< class F, class... Args >
/*не определено*/ bind( F&& f, Args&&... args );
| since2=c++20 | dcl2=
template< class F, class... Args >
constexpr /*не определено*/ bind( F&& f, Args&&... args );
}}
{{dcl rev multi | num=2 | since1=c++11 | dcl1=
template< class R, class F, class... Args >
/*не определено*/ bind( F&& f, Args&&... args );
| since2=c++20 | dcl2=
template< class R, class F, class... Args >
constexpr /*не определено*/ bind( F&& f, Args&&... args );
}}
{{dcl end}}

Шаблон функции {{tt|std::bind}} создает оболочку переадресации вызовов для {{c|f}}. Вызов этой оболочки эквивалентен вызову {{c|f}} с некоторыми аргументами, [[#Привязанные аргументы|привязанными]] к {{c|args}}. 

Если {{c|std::is_constructible<std::decay<F>::type, F>::value}} равно {{c|false}} или {{c|std::is_constructible<std::decay<Arg_i>::type, Arg_i>::value}} равно {{c|false}} для любого типа {{tt|Arg_i}} в {{tt|Args}}, программа некорректна.

Если {{c/core|std::decay<Ti>::type}} или любой тип в {{tt|Args}} не является {{named req|MoveConstructible}} или {{named req|Destructible}}, поведение не определено.

===Параметры===
{{par begin}}
{{par | f | объект {{named req|Callable}} (объект функции, указатель на функцию, ссылка на функцию, указатель на функцию-элемент или указатель на элемент данных), который будет привязан к некоторым аргументам}}
{{par | args | список аргументов для привязки, где несвязанные аргументы заменены {{rlp|placeholders|заполнителями}} {{c|_1}}, {{c|_2}}, {{c|_3}}... пространства имён {{tt|std::placeholders}} }}
{{par end}}

===Возвращаемое значение===
Объект функции {{c|g}} неопределённого типа {{tt|T}} для которого {{c|std::is_bind_expression<T>::value}} равно {{c|true}}. В него входят следующие элементы:

{{member | {{small|std::bind}} ''возвращаемый тип'' | 2=

====Объекты-элементы====
Тип возвращаемого значения {{tt|std::bind}} содержит объект-элемент типа {{c/core|std::decay<F>::type}}, созданный из {{c|std::forward<F>(f)}} и по одному объекту на каждый из {{tt|args...}} типа {{c/core|std::decay<Arg_i>::type}}, аналогично созданному из {{c|std::forward<Arg_i>(arg_i)}}.

====Конструкторы====
Тип возвращаемого значения {{tt|std::bind}} является {{named req|CopyConstructible}}, если все его объекты-элементы (указанные выше) являются CopyConstructible, и {{named req|MoveConstructible}} иначе. Тип определяет следующие элементы:

{{rrev|until=c++20|
====Тип элемент {{tt|result_type}}====
@1@ {{mark deprecated c++17}} Если {{tt|F}} является указателем на функцию или указателем на функцию-элемент, {{tt|result_type}} является возвращаемым типом {{tt|F}}. Если {{tt|F}} является типом класса с вложенным typedef {{tt|result_type}}, то {{tt|result_type}} является {{tt|F::result_type}}. Иначе {{tt|result_type}} не определён.

@2@ {{mark deprecated c++17}} {{tt|result_type}} является точно {{tt|R}}.
}}

====Функция элемент {{tt|operator()}}====
Когда {{c|g}} вызывается в выражении вызова функции {{c|g(u1, u2, ... uM)}}, происходит вызов сохраненного объекта, как если бы

@1@ {{box|{{rlpi|/|INVOKE}}{{c/core|(fd, std::forward<V1>(v1), std::forward<V2>(v2), ..., std::forward<VN>(vN))}}}}, или
@2@ {{box|{{rlpi|/|INVOKE<R>}}{{c/core|(fd, std::forward<V1>(v1), std::forward<V2>(v2), ..., std::forward<VN>(vN))}}}},

где {{c|fd}} это значение типа {{c|std::decay<F>::type}}, значения и типы связанных аргументов {{c|v1}}{{tt|, }}{{c|v2}}{{tt|, ..., }}{{c|vN}} определяются, как указано [[#Привязанные аргументы|ниже]].

Если некоторые из аргументов, предоставленных при вызове {{c|g()}}, не совпадают ни с одним заполнителем, хранящимся в {{c|g}}, неиспользуемые аргументы оцениваются и отбрасываются.

Вызов {{c/core|operator()}} это [[cpp/language/noexcept|не генерирует исключение]] {{rev inl|since=c++20|ли является [[cpp/language/constant expression|константным подвыражением]]}} если и только если такова базовая операция {{tti|INVOKE}}. {{c/core|operator()}} участвует в разрешении перегрузки только в том случае, если операция {{tti|INVOKE}} имеет правильный формат при обработке как невычисленного операнда.

Если {{c|g}} является [[cpp/language/cv|volatile]]-квалифицированным, программа некорректна.

Если {{box|{{rlpi|/|INVOKE}}{{c/core|(fd, w1, w2, ..., wN)}}}} никогда не может быть допустимым выражением для любых возможных значений {{c|w1}}{{tt|, }}{{c|w2}}{{tt|, ..., }}{{c|wN}}, поведение не определено.
}}

===Привязанные аргументы===
В операции {{rlpi|/|INVOKE}} или {{rlpi|/|INVOKE<R>}} Для каждого сохранённого аргумента {{c|arg_i}} определяется соответствующий связанный аргумент {{c|v_i}} следующим образом:

====Случай 1: обёртки ссылок====
Если {{c|arg_i}} имеет тип {{c/core|std::reference_wrapper<T>}} (например, {{lc|std::ref}} или {{lc|std::cref}} использовались при первоначальном вызове {{tt|std::bind}}), тогда {{c|v_i}} равно {{c|arg_i.get()}} и его тип {{tt|V_i}} равен {{tt|T&}}: сохранённый аргумент передаётся по ссылке в вызываемый функциональный объект.

====Случай 2: выражения привязки====
Если {{c|arg_i}} имеет тип {{tt|T}}, для которого {{c|std::is_bind_expression<T>::value}} имеет значение {{c|true}} (например, другое выражение {{tt|std::bind}} было передано непосредственно в начальный вызов {{tt|std::bind}}), тогда {{tt|std::bind}} выполняет композицию функций: вместо передачи функционального объекта, который будет возвращён подвыражением привязки, подвыражение с готовностью вызывается, и его возвращаемое значение передаётся внешнему вызываемому объекту. Если подвыражение привязки имеет какие-либо аргументы-заполнители, они используются совместно с внешней привязкой (выбранной из {{c|u1}}{{tt|, }}{{c|u2}}{{tt|, ...}}). В частности, {{c|v_i}} это {{c|arg_i(std::forward<Uj>(uj)...)}}, а его тип {{tt|V_i}} есть {{rev inl|until=c++17|{{c/core|std::result_of<T}} ''cv''{{sep}}{{c/core|&(Uj&&...)>::type&&}}}}{{rev inl|since=c++17|{{c/core|std::invoke_result_t<T}} ''cv''{{sep}}{{c/core|&, Uj&&...>&&}}}} (cv-квалификация такая же, как у {{c|g}}).

====Случай 3: заполнители====
Если {{c|arg_i}} имеет тип {{tt|T}}, для которого {{c|std::is_placeholder<T>::value}} не является {{c|0}} (это означает, что заполнитель, такой как {{tt|std::placeholders::_1, _2, _3, ...}}, использовался в качестве аргумента для начального вызова {{tt|std::bind}}), тогда аргумент, указанный заполнителем ({{c|u1}} для {{c|_1}}, {{c|u2}} для {{c|_2}} и.д.), передаётся вызываемому объекту: {{c|v_i}} это {{c|std::forward<Uj>(uj)}}, а его тип {{tt|V_i}} это {{tt|Uj&&}}.

====Случай 4: обычные аргументы====
Иначе {{c|arg_i}} передаётся вызываемому объекту в качестве аргумента lvalue: {{c|v_i}} просто {{c|arg_i}}, а его тип {{tt|V_i}} равен {{tt|T}} ''cv''{{sep}}{{tt|&}}, где ''cv'' та же самая cv-квалификация, что и у {{c|g}}.

===Исключения===
Генерируется, только если создание {{c/core|std::decay<F>::type}} из {{c|std::forward<F>(f)}} генерирует исключения, или если любой из конструкторов для {{c/core|std::decay<Arg_i>::type}} из соответствующего {{c|std::forward<Arg_i>(arg_i)}} генерирует исключения, где {{c|Arg_i}} i-й тип, а {{tt|arg_i}} i-й аргумент в {{tt|Args... args}}.

===Примечание===
Как описано в {{named req|Callable}}, при вызове указателя на нестатическую функцию-элемент или указателя на нестатический элемент данных первый аргумент должен быть ссылкой или указателем (включая, возможно, умный указатель, такой как {{lc|std::shared_ptr}} и {{lc|std::unique_ptr}}) на объект, элемент которого будет доступен.

Аргументы для привязки копируются или перемещаются и никогда не передаются по ссылке, если только они не заключены в {{lc|std::ref}} или {{lc|std::cref}}.

Повторяющиеся заполнители в одном и том же выражении привязки (например, несколько {{c|_1}}) допускаются, но результаты корректно определены только в том случае, если соответствующий аргумент ({{tt|u1}}) является lvalue или не перемещаемое rvalue.

===Пример===
{{example
 |
 | code=
#include <functional>
#include <iostream>
#include <memory>
#include <random>

void f(int n1, int n2, int n3, const int& n4, int n5)
{
    std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
}

int g(int n1)
{
    return n1;
}

struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout << n1+n2 << '\n';
    }
    int data = 10;
};

int main()
{
    using namespace std::placeholders;  // for _1, _2, _3...

    std::cout << "1) переупорядочивание аргументов и передача по ссылке: ";
    int n = 7;
    // (_1 и _2 взяты из std::placeholders, и представляют
    // будущие аргументы, которые будут переданы в f1)
    auto f1 = std::bind(f, _2, 42, _1, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 связан с _1, 2 связан с _2, 1001 не используется
                    // вызывает f(2, 42, 1, n, 7)

    std::cout << "2) достижение того же эффекта с помощью лямбда: ";
    n = 7;
    auto lambda = [&ncref=n, n](auto a, auto b, auto /*не используется*/) {
        f(b, 42, a, ncref, n);
    };
    n = 10;
    lambda(1, 2, 1001); // то же, что и вызов f1(1, 2, 1001)

    std::cout << "3) вложенные подвыражения связывания совместно используют заполнители: ";
    auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
    f2(10, 11, 12); // вызывает f(12, g(12), 12, 4, 5);

    std::cout << "4) связывает RNG с распределением: ";
    std::default_random_engine e;
    std::uniform_int_distribution<> d(0, 10);
    auto rnd = std::bind(d, e); // копия e хранится в rnd
    for(int n=0; n<10; ++n)
        std::cout << rnd() << ' ';
    std::cout << '\n';

    std::cout << "5) привязка к указателю на функцию-элемент: ";
    Foo foo;
    auto f3 = std::bind(&Foo::print_sum, &foo, 95, _1);
    f3(5);

    std::cout << "6) привязка к mem_fn, который является указателем на функцию-элемент: ";
    auto ptr_to_print_sum = std::mem_fn(&Foo::print_sum);
    auto f4 = std::bind(ptr_to_print_sum, &foo, 95, _1);
    f4(5);

    std::cout << "7) привязка к указателю на элемент данных: ";
    auto f5 = std::bind(&Foo::data, _1);
    std::cout << f5(foo) << '\n';

    std::cout << "8) привязка к mem_fn, который является указателем на элемент данных: ";
    auto ptr_to_data = std::mem_fn(&Foo::data);
    auto f6 = std::bind(ptr_to_data, _1);
    std::cout << f6(foo) << '\n';

    std::cout << "9) использует умные указатели для вызова элементов по ссылке "
                 "на объекты: ";
    std::cout << f6(std::make_shared<Foo>(foo)) << ' '
              << f6(std::make_unique<Foo>(foo)) << '\n';
}
 | output=
1) переупорядочивание аргументов и передача по ссылке: 2 42 1 10 7
2) достижение того же эффекта с помощью лямбда: 2 42 1 10 7
3) вложенные подвыражения связывания совместно используют заполнители: 12 12 12 4 5
4) связывает RNG с распределением: 0 1 8 5 5 2 0 7 7 10 
5) привязка к указателю на функцию-элемент: 100
6) привязка к mem_fn, который является указателем на функцию-элемент: 100
7) привязка к указателю на элемент данных: 10
8) привязка к mem_fn, который является указателем на элемент данных: 10
9) использует умные указатели для вызова элементов по ссылке на объекты: 10 10
}}

===Отчёты о дефектах===
{{dr list begin}}
{{dr list item|wg=lwg|dr=2021|std=C++11|before=1. привязанные аргументы<br>{{nbsp|4}}не были переправлены в {{c|fd}}<br>2. в случае 2, тип {{tt|V_i}} был<br>{{nbsp|4}}{{c/core|std::result_of<T}} ''cv''{{sep}}{{c/core|(Uj...)>::type}}|after=1. переправлены<br>2. изменён на<br>{{nbsp|4}}{{c/core|std::result_of<T}} ''cv''{{sep}}{{c/core|&(Uj&&...)>::type&&}}}}
{{dr list end}}

===Смотрите также===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bind_front}}
{{dsc inc | cpp/utility/functional/dsc placeholders}}
{{dsc inc | cpp/utility/functional/dsc mem_fn}}
{{dsc end}}

{{langlinks|de|en|es|fr|it|ja|pt|zh}}
Шаблоны, используемые на этой странице:
Возврат к странице cpp/utility/functional/bind.
cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

Просмотр кода страницы cpp/utility/functional/bind

Навигация

Инструменты
