<functional>, funkcje

Te funkcje są przestarzałe w języku C++11 i usuwane w języku C++17:

bind1st
bind2nd
mem_fun
mem_fun_ref
ptr_fun

Te funkcje są przestarzałe w języku C++17:

not1
not2

bind

Wiąże argumenty z obiektem, który można wywołać.

template <class FT, class T1, class T2, ..., class TN>
    unspecified bind(FT fn, T1 t1, T2 t2, ..., TN tN);

template <class RTy, class FT, class T1, class T2, ..., class TN>
    unspecified bind(FT fn, T1 t1, T2 t2, ..., TN tN);

Parametry

FT
Typ obiektu do wywołania. Na przykład typ funkcji, obiekt funkcji, wskaźnik/odwołanie funkcji lub wskaźnik funkcji składowej.

RTy
Zwracany typ. Po określeniu będzie to zwracany typ powiązanego wywołania. W przeciwnym razie zwracany typ to zwracany typ FT.

TN
Typ argumentu wywołania Nth.

fn
Obiekt do wywołania.

tN
Argument wywołania Nth.

Uwagi

Typy FT, T1, T2, ..., TN muszą być konstruowalne i INVOKE(fn, t1, ..., tN) muszą być prawidłowym wyrażeniem dla niektórych wartości w1, w2, ..., wN.

Pierwsza funkcja szablonu zwraca otokę g wywołań przekazujących ze słabym typem wyniku. Efekt g(u1, u2, ..., uM) jestINVOKE(f, v1, v2, ..., vN, invoke_result<FT cv (V1, V2, ..., VN)>::type), gdzie cv to kwalifikatory g cv, a wartości i typy argumentów powiązanych v1, v2, ..., vN są określane zgodnie z poniższym opisem. Służy do powiązania argumentów z obiektem wywołującym w celu utworzenia obiektu z możliwością wywołania z dostosowaną listą argumentów.

Druga funkcja szablonu zwraca otokę g wywołań przekazujących z zagnieżdżonym typemresult_type, który jest synonimem .RTy Efekt g(u1, u2, ..., uM) to , gdzie cv to kwalifikatory g cv, a wartości i typy powiązanych argumentów v1, v2, ..., vN są określane zgodnie z INVOKE(f, v1, v2, ..., vN, RTy)poniższym opisem. Służy do powiązania argumentów z obiektem wywołującym w celu utworzenia obiektu z możliwością wywołania z listą dostosowanych argumentów i określonym typem zwrotnym.

Wartości argumentów powiązanych v1, v2, ..., vN i odpowiadających im typów V1, V2, ..., VN zależą od typu odpowiadającego mu argumentu ti typu Ti w wywołaniu metody bind i kwalifikatorów cv cv otoki g wywołań w następujący sposób:

Jeśli ti jest typem reference_wrapper<T> argumentu vi , ti.get() a jego typem Vi jest T&;

Jeśli wartość std::is_bind_expression<Ti>::value jest argumentem vi , ti(u1, u2, ..., uM) a jego typem Vi jest result_of<Ticv(U1&, U2&, ..., UN&>::type;true

Jeśli wartość jstd::is_placeholder<Ti>::value nie jest równa zero, argument vi to uj , a jego typ Vi to Uj&;

W przeciwnym razie argument to , a jego typ Vi to&cvTi .viti

Na przykład, biorąc pod uwagę funkcję f(int, int)bind(f, _1, 0) wyrażenie zwraca otokę cw wywołań przekazujących, która cw(x) wywołuje f(x, 0)metodę . Wyrażenie bind(f, 0, _1) zwraca otokę cw wywołań przekazujących, która cw(x) wywołuje f(0, x)metodę .

Liczba argumentów w wywołaniu metody bind i argument fn musi być równa liczbie argumentów, które można przekazać do obiektu fnwywołującego . Na przykład bind(cos, 1.0) jest poprawny, a oba bind(cos) i bind(cos, _1, 0.0) są niepoprawne.

Liczba argumentów w wywołaniu funkcji do otoki wywołań zwracanych przez bind element musi być co najmniej tak duża, jak największa liczba is_placeholder<PH>::value argumentów dla wszystkich argumentów symboli zastępczych w wywołaniu metody bind. Na przykład bind(cos, _2)(0.0, 1.0) wartość jest poprawna (i zwraca cos(1.0)wartość ) i bind(cos, _2)(0.0) jest niepoprawna.

Przykład

// std__functional__bind.cpp
// compile with: /EHsc
#include <functional>
#include <algorithm>
#include <iostream>

using namespace std::placeholders;

void square(double x)
{
    std::cout << x << "^2 == " << x * x << std::endl;
}

void product(double x, double y)
{
    std::cout << x << "*" << y << " == " << x * y << std::endl;
}

int main()
{
    double arg[] = { 1, 2, 3 };

    std::for_each(&arg[0], arg + 3, square);
    std::cout << std::endl;

    std::for_each(&arg[0], arg + 3, std::bind(product, _1, 2));
    std::cout << std::endl;

    std::for_each(&arg[0], arg + 3, std::bind(square, _1));

    return (0);
}

1^2 == 1
2^2 == 4
3^2 == 9

1*2 == 2
2*2 == 4
3*2 == 6

1^2 == 1
2^2 == 4
3^2 == 9

bind1st

Funkcja szablonu pomocnika, która tworzy adapter do konwertowania obiektu funkcji binarnej na obiekt funkcji jednoargumentowej. Wiąże pierwszy argument funkcji binarnej z określoną wartością. Przestarzałe w języku C++11 usunięte w języku C++17.

template <class Operation, class Type>
    binder1st <Operation> bind1st (const Operation& func, const Type& left);

Parametry

func
Obiekt funkcji binarnej, który ma zostać przekonwertowany na obiekt funkcji jednoargumentowej.

left
Wartość, do której należy powiązać pierwszy argument obiektu funkcji binarnej.

Wartość zwracana

Obiekt funkcji jednoargumentowej, który wynika z powiązania pierwszego argumentu obiektu funkcji binarnej z wartością left.

Uwagi

Powiązania funkcji są rodzajem adaptera funkcji. Ponieważ zwracają obiekty funkcji, mogą być używane w niektórych typach kompozycji funkcji do konstruowania bardziej skomplikowanych i zaawansowanych wyrażeń.

Jeśli func jest obiektem typu Operation i c jest stałą, bind1st( func, c ) jest to samo co binder1st konstruktor binder1st<Operation>(func, c)klasy , i jest bardziej wygodne do użycia.

Przykład

// functional_bind1st.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

using namespace std;

// Creation of a user-defined function object
// that inherits from the unary_function base class
class greaterthan5: unary_function<int, bool>
{
public:
    result_type operator()(argument_type i)
    {
        return (result_type)(i > 5);
    }
};

int main()
{
    vector<int> v1;
    vector<int>::iterator Iter;

    int i;
    for (i = 0; i <= 5; i++)
    {
        v1.push_back(5 * i);
    }

    cout << "The vector v1 = ( " ;
    for (Iter = v1.begin(); Iter != v1.end(); Iter++)
        cout << *Iter << " ";
    cout << ")" << endl;

    // Count the number of integers > 10 in the vector
    vector<int>::iterator::difference_type result1a;
    result1a = count_if(v1.begin(), v1.end(), bind1st(less<int>(), 10));
    cout << "The number of elements in v1 greater than 10 is: "
         << result1a << "." << endl;

    // Compare: counting the number of integers > 5 in the vector
    // with a user defined function object
    vector<int>::iterator::difference_type result1b;
    result1b = count_if(v1.begin(), v1.end(), greaterthan5());
    cout << "The number of elements in v1 greater than 5 is: "
         << result1b << "." << endl;

    // Count the number of integers < 10 in the vector
    vector<int>::iterator::difference_type result2;
    result2 = count_if(v1.begin(), v1.end(), bind2nd(less<int>(), 10));
    cout << "The number of elements in v1 less than 10 is: "
         << result2 << "." << endl;
}

The vector v1 = ( 0 5 10 15 20 25 )
The number of elements in v1 greater than 10 is: 3.
The number of elements in v1 greater than 5 is: 4.
The number of elements in v1 less than 10 is: 2.

bind2nd

Funkcja szablonu pomocnika, która tworzy adapter do konwertowania obiektu funkcji binarnej na obiekt funkcji jednoargumentowej. Wiąże drugi argument funkcji binarnej z określoną wartością. Przestarzałe w języku C++11 usunięte w języku C++17.

template <class Operation, class Type>
    binder2nd <Operation> bind2nd(const Operation& func, const Type& right);

Parametry

func
Obiekt funkcji binarnej, który ma zostać przekonwertowany na obiekt funkcji jednoargumentowej.

right
Wartość, do której ma być powiązany drugi argument obiektu funkcji binarnej.

Wartość zwracana

Wynik obiektu funkcji jednoargumentowej powiązania drugiego argumentu obiektu funkcji binarnej z .right

Uwagi

Powiązania funkcji są rodzajem adaptera funkcji. Ponieważ zwracają obiekty funkcji, mogą być używane w niektórych typach kompozycji funkcji do konstruowania bardziej skomplikowanych i zaawansowanych wyrażeń.

Jeśli func jest obiektem typu Operation i c jest stałą, bind2nd(func, c) jest to samo co binder2nd konstruktor binder2nd<Operation>(func, c)klasy , i wygodniejsze do użycia.

Przykład

// functional_bind2nd.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

using namespace std;

// Creation of a user-defined function object
// that inherits from the unary_function base class
class greaterthan15: unary_function<int, bool>
{
public:
    result_type operator()(argument_type i)
    {
        return (result_type)(i > 15);
    }
};

int main()
{
    vector<int> v1;
    vector<int>::iterator Iter;

    int i;
    for (i = 0; i <= 5; i++)
    {
        v1.push_back(5 * i);
    }

    cout << "The vector v1 = ( ";
    for (Iter = v1.begin(); Iter != v1.end(); Iter++)
        cout << *Iter << " ";
    cout << ")" << endl;

    // Count the number of integers > 10 in the vector
    vector<int>::iterator::difference_type result1a;
    result1a = count_if(v1.begin(), v1.end(), bind2nd(greater<int>(), 10));
    cout << "The number of elements in v1 greater than 10 is: "
         << result1a << "." << endl;

    // Compare counting the number of integers > 15 in the vector
    // with a user-defined function object
    vector<int>::iterator::difference_type result1b;
    result1b = count_if(v1.begin(), v1.end(), greaterthan15());
    cout << "The number of elements in v1 greater than 15 is: "
         << result1b << "." << endl;

    // Count the number of integers < 10 in the vector
    vector<int>::iterator::difference_type result2;
    result2 = count_if(v1.begin(), v1.end(), bind1st(greater<int>(), 10));
    cout << "The number of elements in v1 less than 10 is: "
         << result2 << "." << endl;
}

The vector v1 = ( 0 5 10 15 20 25 )
The number of elements in v1 greater than 10 is: 3.
The number of elements in v1 greater than 15 is: 2.
The number of elements in v1 less than 10 is: 2.

bit_and

Wstępnie zdefiniowany obiekt funkcji, który wykonuje bitową operację AND (binarną operator&) na argumentach.

template <class Type = void>
struct bit_and : public binary_function<Type, Type, Type
{
    Type operator()(
    const Type& Left,
    const Type& Right) const;
};

// specialized transparent functor for operator&
template <>
struct bit_and<void>
{
    template <class T, class U>
    auto operator()(T&& Left, U&& Right) const  ->
        decltype(std::forward<T>(Left) & std::forward<U>(Right));
};

Parametry

Type, T, U
Dowolny typ obsługujący argument , który operator& przyjmuje operandy określonych lub wywnioskowanych typów.

Left
Lewy operand operacji BITOWEJ AND. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu T.

Right
Prawy operand operacji BITOWEJ AND. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu U.

Wartość zwracana

Wynik .Left & Right Wyspecjalizowany szablon wykonuje doskonałe przekazywanie wyniku, który ma typ zwracany przez operator&element .

Uwagi

Functor bit_and jest ograniczony do typów całkowitych dla podstawowych typów danych lub typów zdefiniowanych przez użytkownika, które implementują binarne operator&.

bit_not

Wstępnie zdefiniowany obiekt funkcji, który wykonuje operację bitowego uzupełniania (NOT) (jednoargumentową operator~) na jego argumencie. Dodano w języku C++14.

template <class Type = void>
struct bit_not : public unary_function<Type, Type>
{
    Type operator()(const Type& Right) const;
};

// specialized transparent functor for operator~
template <>
struct bit_not<void>
{
    template <class Type>
    auto operator()(Type&& Right) const -> decltype(~std::forward<Type>(Right));
};

Parametry

Type
Typ obsługujący jednoargumentowy operator~.

Right
Operand operacji uzupełniania bitowego. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentu odwołania lvalue lub rvalue wywnioskowanego typu Type.

Wartość zwracana

Wynik .~ Right Wyspecjalizowany szablon wykonuje doskonałe przekazywanie wyniku, który ma typ zwracany przez operator~element .

Uwagi

Functor bit_not jest ograniczony do typów całkowitych dla podstawowych typów danych lub typów zdefiniowanych przez użytkownika, które implementują binarne operator~.

bit_or

Wstępnie zdefiniowany obiekt funkcji, który wykonuje bitową operację OR (operator|) na argumentach.

template <class Type = void>
struct bit_or : public binary_function<Type, Type, Type>
{
    Type operator()(
    const Type& Left,
    const Type& Right) const;
};

// specialized transparent functor for operator|
template <>
struct bit_or<void>
{
    template <class T, class U>
    auto operator()(T&& Left, U&& Right) const
        -> decltype(std::forward<T>(Left) | std::forward<U>(Right));
};

Parametry

Type, T, U
Dowolny typ obsługujący argument , który operator| przyjmuje operandy określonych lub wywnioskowanych typów.

Left
Lewy operand operacji bitowej OR. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu T.

Right
Prawy operand operacji bitowej OR. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu U.

Wartość zwracana

Wynik .Left | Right Wyspecjalizowany szablon wykonuje doskonałe przekazywanie wyniku, który ma typ zwracany przez operator|element .

Uwagi

Functor bit_or jest ograniczony do typów całkowitych dla podstawowych typów danych lub typów zdefiniowanych przez użytkownika, które implementują operator|.

bit_xor

Wstępnie zdefiniowany obiekt funkcji, który wykonuje bitową operację XOR (binarną operator^) na argumentach.

template <class Type = void>
struct bit_xor : public binary_function<Type, Type, Type>
{
    Type operator()(
    const Type& Left,
    const Type& Right) const;
};

// specialized transparent functor for operator^
template <>
struct bit_xor<void>
{
    template <class T, class U>
    auto operator()(T&& Left, U&& Right) const
        -> decltype(std::forward<T>(Left) ^ std::forward<U>(Right));
};

Parametry

Type, T, U
Dowolny typ obsługujący argument , który operator^ przyjmuje operandy określonych lub wywnioskowanych typów.

Left
Lewy operand operacji XOR bitowej. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu T.

Right
Prawy operand operacji XOR bitowej. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu U.

Wartość zwracana

Wynik .Left ^ Right Wyspecjalizowany szablon wykonuje doskonałe przekazywanie wyniku, który ma typ zwracany przez operator^element .

Uwagi

Functor bit_xor jest ograniczony do typów całkowitych dla podstawowych typów danych lub typów zdefiniowanych przez użytkownika, które implementują binarne operator^.

Cref

Tworzy const reference_wrapper z argumentu.

template <class Ty>
reference_wrapper<const Ty> cref(const Ty& arg);

template <class Ty>
reference_wrapper<const Ty> cref(const reference_wrapper<Ty>& arg);

Parametry

Ty
Typ argumentu do opakowania.

arg
Argument do zawijania.

Uwagi

Pierwsza funkcja zwraca wartość reference_wrapper<const Ty>(arg.get()). Służy do zawijania odwołania const. Druga funkcja zwraca wartość reference_wrapper<const Ty>(arg). Służy do ponownego opakowania opakowanego odwołania jako odwołania const.

Przykład

// std__functional__cref.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
{
    return (-val);
}

int main()
{
    int i = 1;

    std::cout << "i = " << i << std::endl;
    std::cout << "cref(i) = " << std::cref(i) << std::endl;
    std::cout << "cref(neg)(i) = "
        << std::cref(&neg)(i) << std::endl;

    return (0);
}

i = 1
cref(i) = 1
cref(neg)(i) = -1

Wywołać

Wywołuje dowolny obiekt wywołujący z podanymi argumentami. Dodano w języku C++17.

template <class Callable, class... Args>
invoke_result_t<Callable, Args...>
    invoke(Callable&& fn, Args&&... args) noexcept(/* specification */);

Parametry

Callable
Typ obiektu do wywołania.

Args
Typy argumentów wywołania.

fn
Obiekt do wywołania.

args
Argumenty wywołania.

specification
Specyfikacja noexceptstd::is_nothrow_invocable_v<Callable, Args>).

Uwagi

Wywołuje obiekt fn wywołujący przy użyciu parametrów args. W rzeczywistości , INVOKE(std::forward<Callable>(fn), std::forward<Args>(args)...)gdzie pseudo-funkcja INVOKE(f, t1, t2, ..., tN) oznacza jedną z następujących rzeczy:

• (t1.*f)(t2, ..., tN) gdy f jest wskaźnikiem do funkcji składowej klasy T i t1 jest obiektem typu lub odwołaniem do obiektu typu TT lub odwołania do obiektu typu lub odwołania do obiektu typu pochodzącego z Tklasy . To znaczy, kiedy std::is_base_of<T, std::decay_t<decltype(t1)>>::value jest prawdziwe.

• (t1.get().*f)(t2, ..., tN) gdy f jest wskaźnikiem do funkcji składowej klasy T i std::decay_t<decltype(t1)> jest specjalizacją std::reference_wrapper.

• ((*t1).*f)(t2, ..., tN) gdy f jest wskaźnikiem do funkcji składowej klasy T i t1 nie jest jednym z poprzednich typów.

• t1.*f gdy N == 1 i f jest wskaźnikiem do danych składowych klasy T i t1 jest obiektem typu lub odwołaniem do obiektu typu TT lub odwołania do obiektu typu lub odwołania do obiektu typu pochodzącego z Tklasy . To znaczy, kiedy std::is_base_of<T, std::decay_t<decltype(t1)>>::value jest prawdziwe.

• t1.get().*f gdy N == 1 i f jest wskaźnikiem do danych składowych klasy T i std::decay_t<decltype(t1)> jest specjalizacją std::reference_wrapper.

• (*t1).*f gdy N == 1 i f jest wskaźnikiem do danych składowych klasy T i t1 nie jest jednym z poprzednich typów.

• f(t1, t2, ..., tN) we wszystkich innych przypadkach.

Aby uzyskać informacje na temat typu wyniku obiektu z możliwością wywołania, zobacz invoke_result. Aby uzyskać predykaty dla typów możliwych do wywołania, zobacz is_invocable, is_invocable_r, is_nothrow_invocable, is_nothrow_invocable_r klasy.

Przykład

// functional_invoke.cpp
// compile using: cl /EHsc /std:c++17 functional_invoke.cpp
#include <functional>
#include <iostream>

struct Demo
{
    int n_;

    Demo(int const n) : n_{n} {}

    void operator()( int const i, int const j ) const
    {
        std::cout << "Demo operator( " << i << ", "
            << j << " ) is " << i * j << "\n";
    }

    void difference( int const i ) const
    {
        std::cout << "Demo.difference( " << i << " ) is "
            << n_ - i << "\n";
    }
};

void divisible_by_3(int const i)
{
    std::cout << i << ( i % 3 == 0 ? " is" : " isn't" )
        << " divisible by 3.\n";
}

int main()
{
    Demo d{ 42 };
    Demo * pd{ &d };
    auto pmf = &Demo::difference;
    auto pmd = &Demo::n_;

    // Invoke a function object, like calling d( 3, -7 )
    std::invoke( d, 3, -7 );

    // Invoke a member function, like calling
    // d.difference( 29 ) or (d.*pmf)( 29 )
    std::invoke( &Demo::difference, d, 29 );
    std::invoke( pmf, pd, 13 );

    // Invoke a data member, like access to d.n_ or d.*pmd
    std::cout << "d.n_: " << std::invoke( &Demo::n_, d ) << "\n";
    std::cout << "pd->n_: " << std::invoke( pmd, pd ) << "\n";

    // Invoke a stand-alone (free) function
    std::invoke( divisible_by_3, 42 );

    // Invoke a lambda
    auto divisible_by_7 = []( int const i )
    {
        std::cout << i << ( i % 7 == 0 ? " is" : " isn't" )
            << " divisible by 7.\n";
    };
    std::invoke( divisible_by_7, 42 );
}

Demo operator( 3, -7 ) is -21
Demo.difference( 29 ) is 13
Demo.difference( 13 ) is 29
d.n_: 42
pd->n_: 42
42 is divisible by 3.
42 is divisible by 7.

mem_fn

Generuje prostą otokę wywołań.

template <class RTy, class Ty>
unspecified mem_fn(RTy Ty::*pm);

Parametry

RTy
Zwracany typ opakowanej funkcji.

Ty
Typ wskaźnika funkcji składowej.

Uwagi

Funkcja szablonu zwraca prostą otokę cwwywołań z słabym typem wyniku, tak aby wyrażenie cw(t, a2, ..., aN) było takie samo jak INVOKE(pm, t, a2, ..., aN). Nie zgłasza żadnych wyjątków.

Zwrócona otoka wywołań jest pochodna std::unary_function<cv Ty*, RTy> (i definiuje typ result_type zagnieżdżony jako synonim RTy i typ zagnieżdżony jako synonim dla cv Ty*), tylko wtedy, gdy typ argument_typeTy jest wskaźnikiem do funkcji składowej z kwalifikatorem cv cv, który nie przyjmuje żadnych argumentów.

Zwrócona otoka wywołań pochodzi z std::binary_function<cv Ty*, T2, RTy> (i definiuje typ result_type zagnieżdżony jako synonim dla RTy, typ first argument_type zagnieżdżony jako synonim dla cv Ty*, i typ second argument_type zagnieżdżony jako synonim dla T2) tylko wtedy, gdy typ Ty jest wskaźnikiem do funkcji składowej z kwalifikatorem cv cv, który przyjmuje jeden argument typu T2.

Przykład

// std__functional__mem_fn.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

class Funs
{
public:
    void square(double x)
    {
        std::cout << x << "^2 == " << x * x << std::endl;
    }

    void product(double x, double y)
    {
        std::cout << x << "*" << y << " == " << x * y << std::endl;
    }
};

int main()
{
    Funs funs;

    std::mem_fn(&Funs::square)(funs, 3.0);
    std::mem_fn(&Funs::product)(funs, 3.0, 2.0);

    return (0);
}

3^2 == 9
3*2 == 6

mem_fun

Funkcje szablonu pomocnika używane do konstruowania adapterów obiektów funkcji dla funkcji składowych podczas inicjowania z argumentami wskaźnika. Przestarzałe w języku C++11 for mem_fn i bindi usunięte w języku C++17.

template <class Result, class Type>
mem_fun_t<Result, Type> mem_fun (Result(Type::* pMem)());

template <class Result, class Type, class Arg>
mem_fun1_t<Result, Type, Arg> mem_fun(Result (Type::* pMem)(Arg));

template <class Result, class Type>
const_mem_fun_t<Result, Type> mem_fun(Result (Type::* pMem)() const);

template <class Result, class Type, class Arg>
const_mem_fun1_t<Result, Type, Arg> mem_fun(Result (Type::* pMem)(Arg) const);

Parametry

pMem
Wskaźnik do funkcji składowej klasy Type , która ma zostać przekonwertowana na obiekt funkcji.

Wartość zwracana

Obiekt const funkcji innej niż const typu mem_fun_t lub mem_fun1_t.

Przykład

// functional_mem_fun.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

using namespace std;

class StoreVals
{
    int val;
public:
    StoreVals() { val = 0; }
    StoreVals(int j) { val = j; }

    bool display() { cout << val << " "; return true; }
    int squareval() { val *= val; return val; }
    int lessconst(int k) {val -= k; return val; }
};

int main( )
{
    vector<StoreVals *> v1;

    StoreVals sv1(5);
    v1.push_back(&sv1);
    StoreVals sv2(10);
    v1.push_back(&sv2);
    StoreVals sv3(15);
    v1.push_back(&sv3);
    StoreVals sv4(20);
    v1.push_back(&sv4);
    StoreVals sv5(25);
    v1.push_back(&sv5);

    cout << "The original values stored are: " ;
    for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
    cout << endl;

    // Use of mem_fun calling member function through a pointer
    // square each value in the vector using squareval ()
    for_each(v1.begin(), v1.end(), mem_fun<int, StoreVals>(&StoreVals::squareval));
    cout << "The squared values are: " ;
    for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
    cout << endl;

    // Use of mem_fun1 calling member function through a pointer
    // subtract 5 from each value in the vector using lessconst ()
    for_each(v1.begin(), v1.end(),
        bind2nd (mem_fun1<int, StoreVals,int>(&StoreVals::lessconst), 5));
    cout << "The squared values less 5 are: " ;
    for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
    cout << endl;
}

mem_fun_ref

Funkcje szablonu pomocnika używane do konstruowania adapterów obiektów funkcji dla funkcji składowych podczas inicjowania przy użyciu argumentów odwołania. Przestarzałe w języku C++11 usunięte w języku C++17.

template <class Result, class Type>
mem_fun_ref_t<Result, Type> mem_fun_ref(Result (Type::* pMem)());

template <class Result, class Type, class Arg>
mem_fun1_ref_t<Result, Type, Arg> mem_fun_ref(Result (Type::* pMem)(Arg));

template <class Result, class Type>
const_mem_fun_ref_t<Result, Type> mem_fun_ref(Result Type::* pMem)() const);

template <class Result, class Type, class Arg>
const_mem_fun1_ref_t<Result, Type, Arg> mem_fun_ref(Result (T::* pMem)(Arg) const);

Parametry

pMem
Wskaźnik do funkcji składowej klasy Type , która ma zostać przekonwertowana na obiekt funkcji.

Wartość zwracana

Obiekt const lub non_const funkcji typu mem_fun_ref_t lub mem_fun1_ref_t.

Przykład

// functional_mem_fun_ref.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

using namespace std;

class NumVals
{
   int val;
   public:
   NumVals ( ) { val = 0; }
   NumVals ( int j ) { val = j; }

   bool display ( ) { cout << val << " "; return true; }
   bool isEven ( ) { return ( bool )  !( val %2 ); }
   bool isPrime( )
   {
      if (val < 2) { return true; }
      for (int i = 2; i <= val / i; ++i)
      {
         if (val % i == 0) { return false; }
      }
      return true;
   }
};

int main( )
{
   vector <NumVals> v1 ( 13 ), v2 ( 13 );
   vector <NumVals>::iterator v1_Iter, v2_Iter;
   int i, k;

   for ( i = 0; i < 13; i++ ) v1 [ i ] = NumVals ( i+1 );
   for ( k = 0; k < 13; k++ ) v2 [ k ] = NumVals ( k+1 );

   cout << "The original values stored in v1 are: " ;
   for_each( v1.begin( ), v1.end( ),
   mem_fun_ref ( &NumVals::display ) );
   cout << endl;

   // Use of mem_fun_ref calling member function through a reference
   // remove the primes in the vector using isPrime ( )
   v1_Iter = remove_if ( v1.begin( ),  v1.end( ),
      mem_fun_ref ( &NumVals::isPrime ) );
   cout << "With the primes removed, the remaining values in v1 are: " ;
   for_each( v1.begin( ), v1_Iter,
   mem_fun_ref ( &NumVals::display ) );
   cout << endl;

   cout << "The original values stored in v2 are: " ;
   for_each( v2.begin( ), v2.end( ),
   mem_fun_ref ( &NumVals::display ) );
   cout << endl;

   // Use of mem_fun_ref calling member function through a reference
   // remove the even numbers in the vector v2 using isEven ( )
   v2_Iter = remove_if ( v2.begin( ),  v2.end( ),
      mem_fun_ref ( &NumVals::isEven ) );
   cout << "With the even numbers removed, the remaining values are: " ;
   for_each( v2.begin( ),  v2_Iter,
   mem_fun_ref ( &NumVals::display ) );
   cout << endl;
}

The original values stored in v1 are: 1 2 3 4 5 6 7 8 9 10 11 12 13
With the primes removed, the remaining values in v1 are: 4 6 8 9 10 12
The original values stored in v2 are: 1 2 3 4 5 6 7 8 9 10 11 12 13
With the even numbers removed, the remaining values are: 1 3 5 7 9 11 13

not1

Zwraca uzupełnienie predykatu jednoargumentowego. Przestarzałe w not_fn języku C++17.

template <class UnaryPredicate>
unary_negate<UnaryPredicate> not1(const UnaryPredicate& predicate);

Parametry

predicate
Predykat jednoargumentowy do negacji.

Wartość zwracana

Predykat jednoargumentowy, który jest negacją zmodyfikowanego predykatu jednoargumentowego.

Uwagi

Jeśli obiekt unary_negate jest skonstruowany z predykatu predicate(x)jednoargumentowego , zwraca wartość !predicate(x).

Przykład

// functional_not1.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

using namespace std;

int main()
{
    vector<int> v1;
    vector<int>::iterator Iter;

    int i;
    for (i = 0; i <= 7; i++)
    {
        v1.push_back(5 * i);
    }

    cout << "The vector v1 = ( ";
    for (Iter = v1.begin(); Iter != v1.end(); Iter++)
        cout << *Iter << " ";
    cout << ")" << endl;

    vector<int>::iterator::difference_type result1;
    // Count the elements greater than 10
    result1 = count_if(v1.begin(), v1.end(), bind2nd(greater<int>(), 10));
    cout << "The number of elements in v1 greater than 10 is: "
         << result1 << "." << endl;

    vector<int>::iterator::difference_type result2;
    // Use the negator to count the elements less than or equal to 10
    result2 = count_if(v1.begin(), v1.end(),
        not1(bind2nd(greater<int>(), 10)));

    cout << "The number of elements in v1 not greater than 10 is: "
         << result2 << "." << endl;
}

The vector v1 = ( 0 5 10 15 20 25 30 35 )
The number of elements in v1 greater than 10 is: 5.
The number of elements in v1 not greater than 10 is: 3.

not2

Zwraca uzupełnienie predykatu binarnego. Przestarzałe w not_fn języku C++17.

template <class BinaryPredicate>
binary_negate<BinaryPredicate> not2(const BinaryPredicate& func);

Parametry

func
Predykat binarny do zanegowania.

Wartość zwracana

Predykat binarny, który jest negacją zmodyfikowanego predykatu binarnego.

Uwagi

Jeśli element binary_negate jest skonstruowany z predykatu binary_predicate(x, y)binarnego , zwraca wartość !binary_predicate(x, y).

Przykład

// functional_not2.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter1;

   int i;
   v1.push_back( 6262 );
   v1.push_back( 6262 );
   for ( i = 0 ; i < 5 ; i++ )
   {
      v1.push_back( rand( ) );
   }

   cout << "Original vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To sort in ascending order,
   // use default binary predicate less<int>( )
   sort( v1.begin( ), v1.end( ) );
   cout << "Sorted vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To sort in descending order,
   // use the binary_negate helper function not2
   sort( v1.begin( ), v1.end( ), not2(less<int>( ) ) );
   cout << "Resorted vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;
}

Original vector v1 = ( 6262 6262 41 18467 6334 26500 19169 )
Sorted vector v1 = ( 41 6262 6262 6334 18467 19169 26500 )
Resorted vector v1 = ( 26500 19169 18467 6334 6262 6262 41 )

not_fn

Szablon not_fn funkcji przyjmuje obiekt z możliwością wywołania i zwraca obiekt, który można wywołać. Gdy zwrócony obiekt wywoływany jest później wywoływany z niektórymi argumentami, przekazuje je do oryginalnego obiektu z możliwością wywołania i logicznie neguje wynik. Zachowuje zachowanie kategorii const i kategorii wartości opakowanego obiektu wywoływanego. not_fn jest nowy w języku C++17 i zastępuje przestarzałe std::not1, std::not2, std::unary_negatei std::binary_negate.

template <class Callable>
/* unspecified */ not_fn(Callable&& func);

Parametry

func
Obiekt wywołujący używany do konstruowania otoki wywołań przekazujących.

Uwagi

Funkcja szablonu zwraca otokę wywołań, taką jak return call_wrapper(std::forward<Callable>(func)), na podstawie tej klasy tylko ekspozycji:

class call_wrapper
{
   using FD = decay_t<Callable>;
   explicit call_wrapper(Callable&& func);

public:
   call_wrapper(call_wrapper&&) = default;
   call_wrapper(call_wrapper const&) = default;

   template<class... Args>
     auto operator()(Args&&...) & -> decltype(!declval<invoke_result_t<FD&(Args...)>>());

   template<class... Args>
     auto operator()(Args&&...) const& -> decltype(!declval<invoke_result_t<FD const&(Args...)>>());

   template<class... Args>
     auto operator()(Args&&...) && -> decltype(!declval<invoke_result_t<FD(Args...)>>());

   template<class... Args>
     auto operator()(Args&&...) const&& -> decltype(!declval<invoke_result_t<FD const(Args...)>>());

private:
  FD fd;
};

Jawny konstruktor obiektu wywołującego func wymaga typu std::decay_t<Callable> , aby spełnić wymagania , MoveConstructiblei is_constructible_v<FD, Callable> musi mieć wartość true. Inicjuje opakowany obiekt fd wywołujący z std::forward<Callable>(func)obiektu i zgłasza wszelkie wyjątki zgłaszane przez konstrukcję fdobiektu .

Otoka uwidacznia operatory wywołań rozróżniane przez kategorię referencyjną lvalue lub rvalue oraz kwalifikację const, jak pokazano poniżej:

template<class... Args> auto operator()(Args&&... args) & -> decltype(!declval<invoke_result_t<FD&(Args...)>>());
template<class... Args> auto operator()(Args&&... args) const& -> decltype(!declval<invoke_result_t<FD const&(Args...)>>());
template<class... Args> auto operator()(Args&&... args) && -> decltype(!declval<invoke_result_t<FD(Args...)>>());
template<class... Args> auto operator()(Args&&... args) const&& -> decltype(!declval<invoke_result_t<FD const(Args...)>>());

Pierwsze dwa są takie same jak return !std::invoke(fd, std::forward<Args>(args)...). Drugie dwa są takie same jak return !std::invoke(std::move(fd), std::forward<Args>(args)...).

Przykład

// functional_not_fn_.cpp
// compile with: /EHsc /std:c++17
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>

int main()
{
    std::vector<int> v1 = { 99, 6264, 41, 18467, 6334, 26500, 19169 };
    auto divisible_by_3 = [](int i){ return i % 3 == 0; };

    std::cout << "Vector v1 = ( " ;
    for (const auto& item : v1)
    {
        std::cout << item << " ";
    }
    std::cout << ")" << std::endl;

    // Count the number of vector elements divisible by 3.
    int divisible =
        std::count_if(v1.begin(), v1.end(), divisible_by_3);
    std::cout << "Elements divisible by three: "
        << divisible << std::endl;

    // Count the number of vector elements not divisible by 3.
    int not_divisible =
        std::count_if(v1.begin(), v1.end(), std::not_fn(divisible_by_3));
    std::cout << "Elements not divisible by three: "
        << not_divisible << std::endl;
}

Vector v1 = ( 99 6264 41 18467 6334 26500 19169 )
Elements divisible by three: 2
Elements not divisible by three: 5

ptr_fun

Funkcje szablonu pomocnika używane do konwertowania wskaźników funkcji jednoargumentowej i binarnej odpowiednio na funkcje jednoargumentowe i binarne. Przestarzałe w języku C++11 usunięte w języku C++17.

template <class Arg, class Result>
pointer_to_unary_function<Arg, Result, Result (*)(Arg)> ptr_fun(Result (*pfunc)(Arg));

template <class Arg1, class Arg2, class Result>
pointer_to_binary_function<Arg1, Arg2, Result, Result (*)(Arg1, Arg2)> ptr_fun(Result (*pfunc)(Arg1, Arg2));

Parametry

pfunc
Wskaźnik funkcji jednoargumentowej lub binarnej, który ma zostać przekonwertowany na funkcję z możliwością dostosowania.

Wartość zwracana

Pierwsza funkcja szablonu zwraca funkcję jednoargumentową pointer_to_unary_functionResult><Arg (* ). pfunc

Druga funkcja szablonu zwraca funkcję binarną pointer_to_binary_function<Arg1, Arg2, Result>(* ). pfunc

Uwagi

Wskaźnik funkcji jest obiektem funkcji. Może zostać przekazany do dowolnego algorytmu, który oczekuje funkcji jako parametru, ale nie można go dostosować. Informacje o typach zagnieżdżonych są wymagane do użycia z adapterem, na przykład w celu powiązania wartości z nią lub negacji. Konwersja wskaźników funkcji jednoargumentowej i binarnej ptr_fun przez funkcję pomocnika pozwala adapterom funkcji na pracę z jednoargumentowymi i binarnymi wskaźnikami funkcji.

Przykład

// functional_ptr_fun.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <cstring>
#include <iostream>

int main( )
{
    using namespace std;
    vector <char*> v1;
    vector <char*>::iterator Iter1, RIter;

    v1.push_back ( "Open" );
    v1.push_back ( "up" );
    v1.push_back ( "the" );
    v1.push_back ( "opalescent" );
    v1.push_back ( "gates" );

    cout << "Original sequence contains: " ;
    for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; ++Iter1 )
        cout << *Iter1 << " ";
    cout << endl;

    // To search the sequence for "opalescent"
    // use a pointer_to_function conversion
    RIter = find_if( v1.begin( ), v1.end( ),
        not1 ( bind2nd (ptr_fun ( strcmp ), "opalescent" ) ) );

    if ( RIter != v1.end( ) )  
    {
        cout << "Found a match: " 
            << *RIter << endl;
    }
}

ref

Tworzy element reference_wrapper z argumentu.

template <class Ty>
    reference_wrapper<Ty> ref(Ty& arg);

template <class Ty>
    reference_wrapper<Ty> ref(reference_wrapper<Ty>& arg);

Wartość zwracana

Odwołanie do arg; w szczególności reference_wrapper<Ty>(arg).

Przykład

Poniższy przykład definiuje dwie funkcje: jedną powiązaną ze zmienną ciągu, drugą powiązaną z odwołaniem do zmiennej ciągu obliczoną przez wywołanie metody ref. Gdy wartość zmiennej zmieni się, pierwsza funkcja nadal używa starej wartości, a druga funkcja używa nowej wartości.

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>
#include <vector>
using namespace std;
using namespace std;
using namespace std::placeholders;

bool shorter_than(const string& l, const string& r)
{
    return l.size() < r.size();
}

int main()
{
    vector<string> v_original;
    v_original.push_back("tiger");
    v_original.push_back("cat");
    v_original.push_back("lion");
    v_original.push_back("cougar");

    copy(v_original.begin(), v_original.end(), ostream_iterator<string>(cout, " "));
    cout << endl;

    string s("meow");

    function<bool (const string&)> f = bind(shorter_than, _1, s);
    function<bool (const string&)> f_ref = bind(shorter_than, _1, ref(s));

    vector<string> v;

    // Remove elements that are shorter than s ("meow")

    v = v_original;
    v.erase(remove_if(v.begin(), v.end(), f), v.end());

    copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
    cout << endl;

    // Now change the value of s.
    // f_ref, which is bound to ref(s), will use the
    // new value, while f is still bound to the old value.

    s = "kitty";

    // Remove elements that are shorter than "meow" (f is bound to old value of s)

    v = v_original;
    v.erase(remove_if(v.begin(), v.end(), f), v.end());

    copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
    cout << endl;

    // Remove elements that are shorter than "kitty" (f_ref is bound to ref(s))

    v = v_original;
    v.erase(remove_if(v.begin(), v.end(), f_ref), v.end());

    copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
    cout << endl;
}

tiger cat lion cougar
tiger lion cougar
tiger lion cougar
tiger cougar

swap

Zamienia dwa function obiekty.

template <class FT>
    void swap(function<FT>& f1, function<FT>& f2);

Parametry

FT
Typ kontrolowany przez obiekty funkcji.

f1
Pierwszy obiekt funkcji.

f2
Drugi obiekt funkcji.

Uwagi

Funkcja zwraca f1.swap(f2)wartość .

Przykład

// std__functional__swap.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
{
    return (-val);
}

int main()
{
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "val == " << fn0(3) << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << std::endl;

    swap(fn0, fn1);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
}

empty == false
val == -3
empty == true

empty == true
empty == false
val == -3