<functional> – funkce

Tyto funkce jsou zastaralé v jazyce C++11 a odeberou se v jazyce C++17:

bind1st
bind2nd
mem_fun
mem_fun_ref
ptr_fun

V jazyce C++17 jsou tyto funkce zastaralé:

not1
not2

bind

Naváže argumenty na volatelný objekt.

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 objektu, který se má volat. Například typ funkce, objekt funkce, ukazatel funkce/odkaz nebo ukazatel členské funkce.

RTy
Návratový typ. Po zadání se bude jednat o návratový typ vázaného volání. V opačném případě je návratový typ návratového FTtypu .

TN
Typ argumentu Nth call.

fn
Objekt, který se má volat.

tN
Nth call argument.

Poznámky

FT, T1, T2, ..., TN Typy musí být copy-constructible a INVOKE(fn, t1, ..., tN) musí být platným výrazem pro některé hodnoty w1, w2, ..., wN.

První funkce šablony vrátí obálku g volání přesměrování se slabým typem výsledku. Účinek g(u1, u2, ..., uM) je invoke_result<FT cv (V1, V2, ..., VN)>::type), kde cv jsou INVOKE(f, v1, v2, ..., vN, kvalifikátory g cv a hodnoty a typy vázaných argumentů v1, v2, ..., vN jsou určeny, jak je uvedeno níže. Použijete ho k vytvoření volatelného objektu s odkazovatelným objektem s přizpůsobeným seznamem argumentů.

Druhá funkce šablony vrátí obálku g volání přesměrování s vnořeným typem result_type , který je synonymem pro RTy. Účinek g(u1, u2, ..., uM) je , kde cv je INVOKE(f, v1, v2, ..., vN, RTy)kvalifikátory g cv a hodnoty a typy vázaných argumentů v1, v2, ..., vN jsou určeny, jak je uvedeno níže. Slouží k vytvoření volatelného objektu s vazbou argumentů na volatelný objekt se seznamem přizpůsobených argumentů a se zadaným návratovým typem.

Hodnoty vázaných argumentů v1, v2, ..., vN a jejich odpovídajících typů V1, V2, ..., VN závisí na typu odpovídajícího argumentu ti typu Ti v volání bind a kvalifikátory cv cv obálky g volání následujícím způsobem:

Pokud ti je argument typu reference_wrapper<T> vi ti.get() a jeho typ Vi je ;T&

Pokud je hodnota std::is_bind_expression<Ti>::value argumentu vi ti(u1, u2, ..., uM) a jeho typ Vi je result_of<Ti cv (U1&, U2&, ..., UN&>::type;true

Pokud hodnota j std::is_placeholder<Ti>::value není nulová, argument vi je uj a jeho typ Vi je Uj&;

V opačném případě je argument vi a jeho typ Vi je Ti cv &.ti

Například vzhledem k tomu, že funkce f(int, int) výraz bind(f, _1, 0) vrátí obálku cw přesměrování volání tak, aby cw(x) volala f(x, 0). Výraz bind(f, 0, _1) vrátí obálku cw volání přesměrování tak, aby cw(x) volala f(0, x).

Počet argumentů ve volání bind a argument fn musí být roven počtu argumentů, které lze předat volajícímu objektu fn. Je například bind(cos, 1.0) správná a obě bind(cos) a bind(cos, _1, 0.0) jsou nesprávné.

Počet argumentů volání obálky volání vrácené bind funkcí musí být alespoň tak velký jako nejvyšší číslovaný hodnota is_placeholder<PH>::value pro všechny zástupné argumenty volání bindvolání . Je například bind(cos, _2)(0.0, 1.0) správná (a vrací cos(1.0)) a bind(cos, _2)(0.0) je nesprávná.

Příklad

// 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

Pomocná funkce šablony, která vytvoří adaptér pro převod objektu binární funkce na objekt unární funkce. Vytvoří vazbu prvního argumentu binární funkce na zadanou hodnotu. Zastaralé v jazyce C++11, odebrané v jazyce C++17.

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

Parametry

func
Binární objekt funkce, který se má převést na objekt unární funkce.

left
Hodnota, ke které má být vázán první argument objektu binární funkce.

Návratová hodnota

Unární funkce objekt, který je výsledkem vazby prvního argumentu objektu binární funkce na hodnotu left.

Poznámky

Pořadače funkcí jsou druh adaptéru funkce. Vzhledem k tomu, že vracejí objekty funkcí, lze je použít v určitých typech složení funkcí k vytvoření složitějších a výkonnějších výrazů.

Pokud func je objekt typu Operation a c je konstanta, pak bind1st( func, c ) je stejný jako binder1st konstruktor binder1st<Operation>(func, c)třídy a je vhodnější použít.

Příklad

// 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

Pomocná funkce šablony, která vytvoří adaptér pro převod objektu binární funkce na objekt unární funkce. Vytvoří vazbu druhého argumentu binární funkce na zadanou hodnotu. Zastaralé v jazyce C++11, odebrané v jazyce C++17.

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

Parametry

func
Binární objekt funkce, který se má převést na objekt unární funkce.

right
Hodnota, ke které má být vázán druhý argument objektu binární funkce.

Návratová hodnota

Výsledek objektu unární funkce vazby druhého argumentu objektu binární funkce na right.

Poznámky

Pořadače funkcí jsou druh adaptéru funkce. Vzhledem k tomu, že vracejí objekty funkcí, lze je použít v určitých typech složení funkcí k vytvoření složitějších a výkonnějších výrazů.

Pokud func je objekt typu Operation a c je konstanta, pak bind2nd(func, c) je stejný jako binder2nd konstruktor binder2nd<Operation>(func, c)třídy a pohodlnější použít.

Příklad

// 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

Předdefinovaný objekt funkce, který u argumentů provede bitové operace AND (binární operator&).

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, , TU
Libovolný typ, který podporuje operator& operandy zadaných nebo odvozených typů.

Left
Levý operand bitové operace AND. Nespecializovaná šablona přebírá argument odkazu lvalue typu Type. Specializovaná šablona dělá perfektní předávání lvalue a rvalue referenční argumenty odvozeného typu T.

Right
Pravý operand bitové operace AND. Nespecializovaná šablona přebírá argument odkazu lvalue typu Type. Specializovaná šablona dělá perfektní předávání lvalue a rvalue referenční argumenty odvozeného typu U.

Návratová hodnota

Výsledek .Left & Right Specializovaná šablona dělá dokonalé přeposílání výsledku, který má typ vrácený operator&.

Poznámky

Functor bit_and je omezen na integrální typy základních datových typů nebo na uživatelem definované typy, které implementují binární operator&.

bit_not

Předdefinovaný objekt funkce, který u argumentu dělá bitový doplněk (NOT) operace (unární operator~). Přidáno v jazyce 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, který podporuje unární operator~.

Right
Operand bitového doplňku. Nespecializovaná šablona přebírá argument odkazu lvalue typu Type. Specializovaná šablona dělá perfektní předávání lvalue nebo rvalue referenční argument odvozeného typu Type.

Návratová hodnota

Výsledek .~ Right Specializovaná šablona dělá dokonalé přeposílání výsledku, který má typ vrácený operator~.

Poznámky

Functor bit_not je omezen na integrální typy základních datových typů nebo na uživatelem definované typy, které implementují binární operator~.

bit_or

Předdefinovaný objekt funkce, který u argumentů provede bitové operace OR (operator|).

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, , TU
Libovolný typ, který podporuje operator| operandy zadaných nebo odvozených typů.

Left
Levý operand bitové operace OR. Nespecializovaná šablona přebírá argument odkazu lvalue typu Type. Specializovaná šablona dělá perfektní předávání lvalue a rvalue referenční argumenty odvozeného typu T.

Right
Pravý operand bitové operace OR. Nespecializovaná šablona přebírá argument odkazu lvalue typu Type. Specializovaná šablona dělá perfektní předávání lvalue a rvalue referenční argumenty odvozeného typu U.

Návratová hodnota

Výsledek .Left | Right Specializovaná šablona dělá dokonalé přeposílání výsledku, který má typ vrácený operator|.

Poznámky

Functor bit_or je omezen na integrální typy pro základní datové typy nebo na uživatelem definované typy, které implementují operator|.

bit_xor

Předdefinovaný objekt funkce, který u argumentů provede bitové operace XOR (binární operator^).

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, , TU
Libovolný typ, který podporuje operator^ operandy zadaných nebo odvozených typů.

Left
Levý operand bitové operace XOR. Nespecializovaná šablona přebírá argument odkazu lvalue typu Type. Specializovaná šablona dělá perfektní předávání lvalue a rvalue referenční argumenty odvozeného typu T.

Right
Pravý operand bitové operace XOR. Nespecializovaná šablona přebírá argument odkazu lvalue typu Type. Specializovaná šablona dělá perfektní předávání lvalue a rvalue referenční argumenty odvozeného typu U.

Návratová hodnota

Výsledek .Left ^ Right Specializovaná šablona dělá dokonalé přeposílání výsledku, který má typ vrácený operator^.

Poznámky

Functor bit_xor je omezen na integrální typy základních datových typů nebo na uživatelem definované typy, které implementují binární operator^.

cref

Z argumentu vytvoří konstantní reference_wrapper.

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, který chcete zalomit.

arg
Argument, který se má zabalit.

Poznámky

První funkce vrátí reference_wrapper<const Ty>(arg.get()). Použijete ho k zabalení odkazu const. Druhá funkce vrátí reference_wrapper<const Ty>(arg). Použijete ho k přebalování zabaleného odkazu jako odkazu na const.

Příklad

// 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

vyvolat

Vyvolá všechny volatelné objekty s danými argumenty. Přidáno v jazyce C++17.

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

Parametry

Callable
Typ objektu, který se má volat.

Args
Typy argumentů volání.

fn
Objekt, který se má volat.

args
Argumenty volání.

specification
Specifikace noexcept std::is_nothrow_invocable_v<Callable, Args>).

Poznámky

Vyvolá volatelný objekt fn pomocí parametrů args. V podstatě , INVOKE(std::forward<Callable>(fn), std::forward<Args>(args)...)kde pseudo-funkce INVOKE(f, t1, t2, ..., tN) znamená jednu z následujících věcí:

• (t1.*f)(t2, ..., tN) je-li f ukazatel na členovou funkci třídy T a t1 je objekt typu T nebo odkaz na objekt typu T nebo odkaz na objekt typu odvozeného z T. To znamená, že když std::is_base_of<T, std::decay_t<decltype(t1)>>::value je pravda.

• (t1.get().*f)(t2, ..., tN) je-li f ukazatel na členovou funkci třídy T a std::decay_t<decltype(t1)> je specializace std::reference_wrapper.

• ((*t1).*f)(t2, ..., tN) je-li f ukazatel na členovou funkci třídy T a t1 není jedním z předchozích typů.

• t1.*f když N == 1 a f je ukazatelem na členová data třídy T a t1 je objekt typu T nebo odkaz na objekt typu T nebo odkaz na objekt typu odvozeného z T. To znamená, že když std::is_base_of<T, std::decay_t<decltype(t1)>>::value je pravda.

• t1.get().*f když N == 1 a f je ukazatelem na členová data třídy T a std::decay_t<decltype(t1)> je specializace std::reference_wrapper.

• (*t1).*f když N == 1 a f je ukazatelem na členová data třídy T a t1 není jedním z předchozích typů.

• f(t1, t2, ..., tN) ve všech ostatních případech.

Informace o typu výsledku volatelného objektu najdete v tématu invoke_result. Predikáty pro volatelné typy najdete v tématu is_invocable, is_invocable_r, is_nothrow_invocable, is_nothrow_invocable_r třídy.

Příklad

// 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

Vygeneruje jednoduchou obálku volání.

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

Parametry

RTy
Návratový typ zabalené funkce.

Ty
Typ ukazatele členské funkce.

Poznámky

Funkce šablony vrátí jednoduchou obálku cwvolání se slabým typem výsledku, aby výraz cw(t, a2, ..., aN) byl stejný jako INVOKE(pm, t, a2, ..., aN). Nevyvolá žádné výjimky.

Vrácený obálka volání je odvozena od std::unary_function<cv Ty*, RTy> (a definování vnořeného typu result_type jako synonyma pro RTy a vnořeného typu argument_type jako synonyma pro cv Ty*) pouze v případě Ty , že typ je ukazatel na členskou funkci s kvalifikátorem cv cv, který nepřijímá žádné argumenty.

Vrácený obálka volání je odvozena od std::binary_function<cv Ty*, T2, RTy> (a definování vnořeného typu result_type jako synonyma pro RTy, vnořeného typu first argument_type jako synonyma pro cv Ty*) T2second argument_type pouze v případě, že typ Ty je ukazatel na členskou funkci s kvalifikátorem cv cv, který přebírá jeden argument typu typu T2.

Příklad

// 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

Pomocné funkce šablony použité k vytvoření adaptérů objektu funkce pro členské funkce při inicializaci pomocí argumentů ukazatelů. Zastaralé v jazyce C++11 pro mem_fn a bindodebrané v jazyce 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
Ukazatel na členovou funkci třídy Type , která se má převést na objekt funkce.

Návratová hodnota

Objekt const funkce nebo jiný než const typu mem_fun_t nebo mem_fun1_t.

Příklad

// 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

Pomocné funkce šablony používané k vytvoření adaptérů objektu funkce pro členské funkce při inicializaci pomocí referenčních argumentů. Zastaralé v jazyce C++11, odebrané v jazyce 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
Ukazatel na členovou funkci třídy Type , která se má převést na objekt funkce.

Návratová hodnota

non_const Objekt const funkce typu mem_fun_ref_t nebo mem_fun1_ref_t.

Příklad

// 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

Vrací doplněk jednočlenného predikátu. Zastaralé pro not_fn jazyk C++17.

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

Parametry

predicate
Unární predikát, který má být negován.

Návratová hodnota

Unární predikát, který je negace unárního predikátu změněna.

Poznámky

unary_negate Je-li vytvořen z unární predikát predicate(x), pak vrátí !predicate(x).

Příklad

// 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

Vrací doplněk binárního predikátu. Zastaralé pro not_fn jazyk C++17.

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

Parametry

func
Binární predikát, který se má negovat.

Návratová hodnota

Binární predikát, který je negace binárního predikátu změněna.

Poznámky

binary_negate Je-li vytvořen z binárního predikátu binary_predicate(x, y), vrátí .!binary_predicate(x, y)

Příklad

// 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

Šablona not_fn funkce přebírá volatelný objekt a vrací volatelný objekt. Když se vrácený volatelný objekt později vyvolá s některými argumenty, předá je původnímu volatelnému objektu a logicky neguje výsledek. Zachovává chování kategorie const a kategorie zabaleného volatelného objektu. not_fn je nový v jazyce C++17 a nahrazuje zastaralé std::not1, std::not2, std::unary_negatea std::binary_negate.

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

Parametry

func
Volatelný objekt použitý k vytvoření obálky volání přesměrování.

Poznámky

Funkce šablony vrátí obálku volání, jako return call_wrapper(std::forward<Callable>(func))je , na základě této třídy pouze expozice:

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;
};

Explicitní konstruktor na volatelném objektu func vyžaduje typ std::decay_t<Callable> , který splňuje požadavky MoveConstructiblea is_constructible_v<FD, Callable> musí být pravdivý. Inicializuje zabalený volatelný objekt fd z std::forward<Callable>(func), a vyvolá všechny výjimky vyvolané konstrukcí fd.

Obálka zveřejňuje operátory volání rozlišující podle kategorie odkazu lvalue nebo rvalue a kvalifikace const, jak je znázorněno zde:

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...)>>());

První dvě jsou stejné jako return !std::invoke(fd, std::forward<Args>(args)...). Druhé dva jsou stejné jako return !std::invoke(std::move(fd), std::forward<Args>(args)...).

Příklad

// 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

Pomocné funkce šablony používané k převodu unárních a binárních ukazatelů funkcí na unární a binární přizpůsobitelné funkce. Zastaralé v jazyce C++11, odebrané v jazyce 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
Ukazatel unární nebo binární funkce, který se má převést na přizpůsobitelnou funkci.

Návratová hodnota

První funkce šablony vrátí unární funkci pointer_to_unary_function<Arg (Result>* ). pfunc

Druhá funkce šablony vrátí binární funkci pointer_to_binary_function<Arg1, Arg2( Result>* ). pfunc

Poznámky

Ukazatel funkce je objekt funkce. Může se předat libovolnému algoritmu, který očekává funkci jako parametr, ale není přizpůsobitelný. Informace o jeho vnořených typech se vyžadují k jeho použití s adaptérem, například k vytvoření vazby hodnoty nebo k jeho negování. Převod unárních a binárních ukazatelů ptr_fun funkce pomocnou funkcí umožňuje adaptérům funkce pracovat s unárními a binárními ukazateli funkce.

Příklad

// 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

Vytvoří reference_wrapper z argumentu.

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

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

Návratová hodnota

Odkaz na arg; konkrétně reference_wrapper<Ty>(arg).

Příklad

Následující příklad definuje dvě funkce: jedna svázaná s řetězcovou proměnnou, druhá svázaná s odkazem na řetězcovou proměnnou vypočítanou voláním ref. Když se změní hodnota proměnné, první funkce bude nadále používat starou hodnotu a druhá funkce použije novou hodnotu.

#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

Prohodí dva function objekty.

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

Parametry

FT
Typ řízený objekty funkce.

f1
První objekt funkce.

f2
Druhý objekt funkce.

Poznámky

Funkce vrátí f1.swap(f2).

Příklad

// 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