<functional> işlevleri

Bu işlevler C++11'de kullanım dışıdır ve C++17'de kaldırılır:

bind1st
bind2nd
mem_fun
mem_fun_ref
ptr_fun

Bu işlevler C++17'de kullanım dışıdır:

not1
not2

bind

Bağımsız değişkenleri çağırılabilir bir nesneye bağlar.

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

Parametreler

FT
Çağrılacak nesnenin türü. Örneğin, işlevin türü, işlev nesnesi, işlev işaretçisi/başvurusu veya üye işlev işaretçisi.

RTy
Dönüş türü. Belirtildiğinde, ilişkili çağrının dönüş türü olacaktır. Aksi takdirde, dönüş türü dönüş türüdür FT.

TN
N. çağrı bağımsız değişkeninin türü.

fn
Çağrılacak nesne.

tN
N. çağrı bağımsız değişkeni.

Açıklamalar

Türlerin FT, T1, T2, ..., TN kopyalanabilir olması ve INVOKE(fn, t1, ..., tN) bazı değerler w1, w2, ..., wNiçin geçerli bir ifade olması gerekir.

İlk şablon işlevi, zayıf sonuç türüne sahip bir iletme çağrısı sarmalayıcı g döndürür. etkisi g(u1, u2, ..., uM) INVOKE(f, v1, v2, ..., vN, invoke_result<FT cv (V1, V2, ..., VN)>::type), burada cv cv-niteleyicileridir g ve ilişkili bağımsız değişkenlerin v1, v2, ..., vN değerleri ve türleri aşağıda belirtildiği gibi belirlenir. Bunu kullanarak bağımsız değişkenleri çağırılabilir bir nesneye bağlayarak özel bir bağımsız değişken listesiyle çağırılabilir bir nesne oluşturursunuz.

İkinci şablon işlevi, için RTyeş anlamlı olan iç içe bir türe result_type sahip bir iletme çağrısı sarmalayıcı g döndürür. etkisi g(u1, u2, ..., uM) , INVOKE(f, v1, v2, ..., vN, RTy)burada cv cv-niteleyicileridir g ve ilişkili bağımsız değişkenlerin v1, v2, ..., vN değerleri ve türleri aşağıda belirtildiği gibi belirlenir. Özel bir bağımsız değişken listesi ve belirtilen dönüş türüne sahip çağrılabilir bir nesne yapmak için bağımsız değişkenleri çağırılabilir bir nesneye bağlamak için kullanırsınız.

İlişkili bağımsız değişkenlerin v1, v2, ..., vN ve karşılık gelen türlerinin V1, V2, ..., VN değerleri, çağrısındaki türün Ti karşılık gelen bağımsız değişkeninin ti türüne bind ve çağrı sarmalayıcısının g cv niteleyicilerine cv aşağıdaki gibi bağlıdır:

Bağımsız değişken vi ti.get() türündeyse reference_wrapper<T> ti ve türü Vi ise T&;

değeri std::is_bind_expression<Ti>::value bağımsız değişken ti(u1, u2, ..., uM) vi ise true ve türü Vi ise result_of<Ti cv (U1&, U2&, ..., UN&>::type;

değeri j std::is_placeholder<Ti>::value sıfır değilse bağımsız değişken vi ve uj türü Vi ise Uj&;

Aksi takdirde bağımsız değişken ve türü şeklindedir Ti cv &.Vi ti vi

Örneğin, bir işlev f(int, int) verüldüğünde ifade bind(f, _1, 0) çağıran bir iletme çağrısı sarmalayıcı cw cw(x) f(x, 0)döndürür. İfade bind(f, 0, _1) , çağıran bir iletme çağrısı sarmalayıcı cw cw(x) f(0, x)döndürür.

çağrısındaki bind bağımsız değişkenlerin sayısı ve bağımsız değişkeni fn çağırılabilir nesnesine fngeçirilebilen bağımsız değişken sayısına eşit olmalıdır. Örneğin, bind(cos, 1.0) doğrudur ve her ikisi de bind(cos) bind(cos, _1, 0.0) yanlıştır.

tarafından döndürülen bind çağrı sarmalayıcısına yönelik işlev çağrısındaki bağımsız değişkenlerin sayısı, çağrısındaki tüm yer tutucu bağımsız değişkenlerin binden yüksek numaralı değeri is_placeholder<PH>::value kadar büyük olmalıdır. Örneğin, bind(cos, _2)(0.0, 1.0) doğru (ve döndürür cos(1.0)) ve bind(cos, _2)(0.0) yanlıştır.

Örnek

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

İkili işlev nesnesini tek bir işlev nesnesine dönüştürmek için bir bağdaştırıcı oluşturan yardımcı şablon işlevi. İkili işlevin ilk bağımsız değişkenini belirtilen bir değere bağlar. C++11'de kullanım dışı bırakıldı, C++17'de kaldırıldı.

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

Parametreler

func
Bir tek işlev nesnesine dönüştürülecek ikili işlev nesnesi.

left
İkili işlev nesnesinin ilk bağımsız değişkeninin bağlanacağı değer.

Dönüş Değeri

İkili işlev nesnesinin ilk bağımsız değişkeninin değerine leftbağlanmasından kaynaklanan birli işlev nesnesi.

Açıklamalar

İşlev bağlayıcıları bir tür işlev bağdaştırıcısıdır. İşlev nesnelerini döndürdiklerinden, daha karmaşık ve güçlü ifadeler oluşturmak için belirli işlev oluşturma türlerinde kullanılabilirler.

func türündeki Operation bir nesneyse ve c sabitse, bind1st( func, c ) sınıf oluşturucu binder1st<Operation>(func, c)ile binder1st aynıdır ve kullanımı daha uygundur.

Örnek

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

İkili işlev nesnesini tek bir işlev nesnesine dönüştürmek için bir bağdaştırıcı oluşturan yardımcı şablon işlevi. İkili işlevin ikinci bağımsız değişkenini belirtilen bir değere bağlar. C++11'de kullanım dışı bırakıldı, C++17'de kaldırıldı.

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

Parametreler

func
Bir tek işlev nesnesine dönüştürülecek ikili işlev nesnesi.

right
İkili işlev nesnesinin ikinci bağımsız değişkeninin bağlanacağı değer.

Dönüş Değeri

İkili işlev nesnesinin ikinci bağımsız değişkenini öğesine bağlamanın birli işlev nesnesi rightsonucu.

Açıklamalar

İşlev bağlayıcıları bir tür işlev bağdaştırıcısıdır. İşlev nesnelerini döndürdiklerinden, daha karmaşık ve güçlü ifadeler oluşturmak için belirli işlev oluşturma türlerinde kullanılabilirler.

func türündeki Operation bir nesneyse ve c sabitse, bind2nd(func, c) sınıf oluşturucu binder2nd<Operation>(func, c)ile binder2nd aynıdır ve kullanımı daha uygundur.

Örnek

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

Bağımsız değişkenlerinde bit düzeyinde AND işlemi (ikili operator&) işlemine sahip önceden tanımlanmış bir işlev nesnesi.

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

Parametreler

Type, T, U
Belirtilen veya çıkarsanan türlerin işlenenlerini alan bir destekleyen herhangi bir operator& tür.

Left
Bit düzeyinde AND işleminin sol işleneni. Belirtilmemiş şablon türündeki Typebir lvalue başvuru bağımsız değişkenini alır. Özelleştirilmiş şablon, çıkarılmıştır türündeki Tlvalue ve rvalue başvuru bağımsız değişkenlerini mükemmel bir şekilde iletir.

Right
Bit düzeyinde AND işleminin doğru işleneni. Belirtilmemiş şablon türündeki Typebir lvalue başvuru bağımsız değişkenini alır. Özelleştirilmiş şablon, çıkarılmıştır türündeki Ulvalue ve rvalue başvuru bağımsız değişkenlerini mükemmel bir şekilde iletir.

Dönüş Değeri

sonucu.Left & Right Özelleştirilmiş şablon, tarafından operator&döndürülen türe sahip olan sonucun mükemmel iletilmesine sahiptir.

Açıklamalar

bit_and Functor, temel veri türleri için integral türleriyle veya ikiliyi operator&uygulayan kullanıcı tanımlı türler ile sınırlıdır.

bit_not

Bağımsız değişkeninde bit düzeyinde tamamlayıcı (DEĞİl) işlemi (birli operator~) işlemine sahip önceden tanımlanmış bir işlev nesnesi. C++14'te eklendi.

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

Parametreler

Type
Birliyi operator~destekleyen bir tür.

Right
Bit düzeyinde tamamlama işleminin işleneni. Belirtilmemiş şablon türündeki Typebir lvalue başvuru bağımsız değişkenini alır. Özelleştirilmiş şablon, çıkarılmıştır türünde Typebir lvalue veya rvalue başvuru bağımsız değişkenini mükemmel bir şekilde iletir.

Dönüş Değeri

sonucu.~ Right Özelleştirilmiş şablon, tarafından operator~döndürülen türe sahip olan sonucun mükemmel iletilmesine sahiptir.

Açıklamalar

bit_not Functor, temel veri türleri için integral türleriyle veya ikiliyi operator~uygulayan kullanıcı tanımlı türler ile sınırlıdır.

bit_or

Bağımsız değişkenlerinde bit düzeyinde OR işlemi (operator|) işlemi gösteren önceden tanımlanmış bir işlev nesnesi.

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

Parametreler

Type, T, U
Belirtilen veya çıkarsanan türlerin işlenenlerini alan bir destekleyen herhangi bir operator| tür.

Left
Bit düzeyinde OR işleminin sol işleneni. Belirtilmemiş şablon türündeki Typebir lvalue başvuru bağımsız değişkenini alır. Özelleştirilmiş şablon, çıkarılmıştır türündeki Tlvalue ve rvalue başvuru bağımsız değişkenlerini mükemmel bir şekilde iletir.

Right
Bit düzeyinde OR işleminin doğru işleneni. Belirtilmemiş şablon türündeki Typebir lvalue başvuru bağımsız değişkenini alır. Özelleştirilmiş şablon, çıkarılmıştır türündeki Ulvalue ve rvalue başvuru bağımsız değişkenlerini mükemmel bir şekilde iletir.

Dönüş Değeri

sonucu.Left | Right Özelleştirilmiş şablon, tarafından operator|döndürülen türe sahip olan sonucun mükemmel iletilmesine sahiptir.

Açıklamalar

Functor bit_or , temel veri türleri için tam sayı türleriyle veya uygulayan operator|kullanıcı tanımlı türler ile sınırlıdır.

bit_xor

Bağımsız değişkenlerinde bit düzeyinde XOR işlemi (ikili operator^) işlemi gösteren önceden tanımlanmış bir işlev nesnesi.

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

Parametreler

Type, T, U
Belirtilen veya çıkarsanan türlerin işlenenlerini alan bir destekleyen herhangi bir operator^ tür.

Left
Bit tabanlı XOR işleminin sol işleneni. Belirtilmemiş şablon türündeki Typebir lvalue başvuru bağımsız değişkenini alır. Özelleştirilmiş şablon, çıkarılmıştır türündeki Tlvalue ve rvalue başvuru bağımsız değişkenlerini mükemmel bir şekilde iletir.

Right
Bit düzeyinde XOR işleminin sağ işleneni. Belirtilmemiş şablon türündeki Typebir lvalue başvuru bağımsız değişkenini alır. Özelleştirilmiş şablon, çıkarılmıştır türündeki Ulvalue ve rvalue başvuru bağımsız değişkenlerini mükemmel bir şekilde iletir.

Dönüş Değeri

sonucu.Left ^ Right Özelleştirilmiş şablon, tarafından operator^döndürülen türe sahip olan sonucun mükemmel iletilmesine sahiptir.

Açıklamalar

bit_xor Functor, temel veri türleri için integral türleriyle veya ikiliyi operator^uygulayan kullanıcı tanımlı türler ile sınırlıdır.

cref

Bağımsız değişkenden sabit reference_wrapper oluşturur.

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

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

Parametreler

Ty
Kaydıracak bağımsız değişkenin türü.

arg
Kaydıracak bağımsız değişken.

Açıklamalar

İlk işlev döndürür reference_wrapper<const Ty>(arg.get()). Bunu bir const başvuruyu sarmak için kullanırsınız. İkinci işlev döndürür reference_wrapper<const Ty>(arg). Sarmalanmış başvuruyu const başvurusu olarak yeniden yazmak için bunu kullanırsınız.

Örnek

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

çağırmak

Verilen bağımsız değişkenlerle çağrılabilir herhangi bir nesneyi çağırır. C++17'ye eklendi.

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

Parametreler

Callable
Çağrılacak nesnenin türü.

Args
Çağrı bağımsız değişkenlerinin türleri.

fn
Çağrılacak nesne.

args
Çağrı bağımsız değişkenleri.

specification
noexcept belirtimistd::is_nothrow_invocable_v<Callable, Args>).

Açıklamalar

parametresini argskullanarak çağrılabilir nesneyi fn çağırır. Etkili bir şekilde, INVOKE(std::forward<Callable>(fn), std::forward<Args>(args)...)sahte işlevin INVOKE(f, t1, t2, ..., tN) aşağıdakilerden biri anlamına geldiği yerdir:

• (t1.*f)(t2, ..., tN) sınıfının f üye işlevinin T işaretçisi olduğunda ve t1 türünde T bir nesne veya türünden T türetilmiş bir nesneye başvuru ya da türünden türetilmiş Tbir nesneye başvurudur. Yani, doğru olduğunda std::is_base_of<T, std::decay_t<decltype(t1)>>::value .

• (t1.get().*f)(t2, ..., tN) sınıfının f üye işlevinin işaretçisi T olduğunda ve std::decay_t<decltype(t1)> bir uzmanlık alanı std::reference_wrapperolduğunda.

• ((*t1).*f)(t2, ..., tN) when f sınıfının T üye işlevinin işaretçisidir ve t1 önceki türlerden biri değildir.

• t1.*f N == 1 olduğunda ve f bir sınıfın T üye verilerinin işaretçisi olduğunda ve t1 türündeki T bir nesne veya türündeki T bir nesneye başvuru ya da türünden Ttüretilen bir nesneye başvuru olduğunda. Yani, doğru olduğunda std::is_base_of<T, std::decay_t<decltype(t1)>>::value .

• t1.get().*f n == 1 olduğunda ve f bir sınıfın T üye verilerinin işaretçisi olduğunda ve std::decay_t<decltype(t1)> bir uzmanlık alanı std::reference_wrapperolduğunda.

• (*t1).*f when N == 1 ve f bir sınıfın T üye verilerine işaretçidir ve t1 önceki türlerden biri değildir.

• f(t1, t2, ..., tN) diğer tüm durumlarda.

Çağrılabilen bir nesnenin sonuç türü hakkında bilgi için bkz . invoke_result. Çağrılabilen türlerdeki önkoşullar için bkz . is_invocable, is_invocable_r, is_nothrow_invocable is_nothrow_invocable_r sınıfları.

Örnek

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

Basit bir çağrı sarmalayıcı oluşturur.

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

Parametreler

RTy
Sarmalanan işlevin dönüş türü.

Ty
Üye işlev işaretçisinin türü.

Açıklamalar

Şablon işlevi, ifade cw(t, a2, ..., aN) ile aynı INVOKE(pm, t, a2, ..., aN)olacak şekilde zayıf bir sonuç türüne sahip basit bir çağrı sarmalayıcı cwdöndürür. Hiçbir özel durum oluşturmaz.

Döndürülen çağrı sarmalayıcısı, yalnızca türün bağımsız değişken içermeyen cv-niteleyicisi cv olan üye işlevine yönelik bir RTy işaretçi olması durumunda Ty öğesinden std::unary_function<cv Ty*, RTy> türetilir (ve iç içe argument_type türü için eş anlamlı cv Ty*olarak tanımlarresult_type).

Döndürülen çağrı sarmalayıcısı öğesinden std::binary_function<cv Ty*, T2, RTy> türetilir (ve iç içe türü result_type için RTyeş anlamlı olarak, iç içe first argument_type türü için eş anlamlı cv Ty*olarak, iç içe türü second argument_type de için T2eş anlamlı olarak tanımlar), ancak türTy, türünde bir bağımsız değişken T2alan cv-niteleyicisi cv olan üye işlevine yönelik bir işaretçiyse.

Örnek

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

İşaretçi bağımsız değişkenleriyle başlatıldığında üye işlevler için işlev nesnesi bağdaştırıcıları oluşturmak için kullanılan yardımcı şablon işlevleri. ve için mem_fn C++11'de kullanım dışı bırakıldı ve bindC++17'de kaldırıldı.

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

Parametreler

pMem
bir işlev nesnesine dönüştürülecek sınıfın Type üye işlevinin işaretçisi.

Dönüş Değeri

const veya türünde mem_fun_t mem_fun1_tbir veya sabit olmayan işlev nesnesi.

Örnek

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

Başvuru bağımsız değişkenleri kullanılarak başlatıldığında üye işlevleri için işlev nesnesi bağdaştırıcıları oluşturmak için kullanılan yardımcı şablon işlevleri. C++11'de kullanım dışı bırakıldı, C++17'de kaldırıldı.

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

Parametreler

pMem
bir işlev nesnesine dönüştürülecek sınıfın Type üye işlevinin işaretçisi.

Dönüş Değeri

const veya non_const türünde mem_fun_ref_t bir veya mem_fun1_ref_tişlev nesnesi.

Örnek

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

Birli koşulun tamamlayıcısını döndürür. C++17'de için not_fn kullanım dışı bırakıldı.

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

Parametreler

predicate
Birli koşulun iptal edilmesi.

Dönüş Değeri

Birli koşulun olumsuzlanması olan birli koşul değiştirildi.

Açıklamalar

bir unary_negate birli koşuldan predicate(x)oluşturulursa, döndürür !predicate(x).

Örnek

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

İkili koşulun tamamlayıcısını döndürür. C++17'de için not_fn kullanım dışı bırakıldı.

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

Parametreler

func
Olumsuzlanacak ikili koşul.

Dönüş Değeri

değiştirilen ikili koşulun olumsuzlaması olan ikili koşul.

Açıklamalar

bir binary_negate ikili koşuldan binary_predicate(x, y)oluşturulursa, döndürür !binary_predicate(x, y).

Örnek

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

İşlev not_fn şablonu çağrılabilen bir nesne alır ve çağrılabilen bir nesne döndürür. Döndürülen çağrılabilir nesne daha sonra bazı bağımsız değişkenlerle çağrıldığında, bunları özgün çağrılabilir nesneye geçirir ve sonucu mantıksal olarak olumsuzlar. Sarmalanan çağrılabilen nesnenin en sabit niteliğini ve değer kategorisi davranışını korur. not_fnC++17 sürümünde yenidir ve kullanım dışı bırakılmış std::not1, , std::not2std::unary_negateve std::binary_negateöğesinin yerini alır.

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

Parametreler

func
İletme çağrısı sarmalayıcısını oluşturmak için kullanılan çağrılabilen nesne.

Açıklamalar

Şablon işlevi, bu yalnızca edat sınıfını temel alarak gibi return call_wrapper(std::forward<Callable>(func))bir çağrı sarmalayıcı döndürür:

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

Çağrılabilen nesnedeki func açık oluşturucu, gereksinimlerini MoveConstructiblekarşılamak için tür std::decay_t<Callable> gerektirir ve is_constructible_v<FD, Callable> doğru olmalıdır. öğesinden std::forward<Callable>(func)sarmalanmış çağrılabilir nesnesini fd başlatır ve yapısı fdtarafından atılan özel durumları oluşturur.

Sarmalayıcı, burada gösterildiği gibi lvalue veya rvalue başvuru kategorisi ve en sabit niteliğe göre ayırt edilen çağrı işleçlerini kullanıma sunar:

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

İlk ikisi ile return !std::invoke(fd, std::forward<Args>(args)...)aynıdır. İkinci ikisi ile aynıdır return !std::invoke(std::move(fd), std::forward<Args>(args)...).

Örnek

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

Sırasıyla birli ve ikili işlev işaretçilerini birli ve ikili uyarlanabilir işlevlere dönüştürmek için kullanılan yardımcı şablon işlevleri. C++11'de kullanım dışı bırakıldı, C++17'de kaldırıldı.

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

Parametreler

pfunc
Uyarlanabilir bir işleve dönüştürülecek birli veya ikili işlev işaretçisi.

Dönüş Değeri

İlk şablon işlevi, Result>(* pfunc) pointer_to_unary_function<Arg birli işlevi döndürür.

İkinci şablon işlevi, ,> (* pfunc) pointer_to_binary_functionArg1Arg2< ikili işlevi döndürür. Result

Açıklamalar

İşlev işaretçisi bir işlev nesnesidir. Bir işlevi parametre olarak bekleyen herhangi bir algoritmaya geçirilebilir, ancak uyarlanabilir değildir. İç içe türleri hakkındaki bilgiler, bir bağdaştırıcıyla kullanmak, örneğin bir değeri ona bağlamak veya olumsuz kullanmak için gereklidir. Yardımcı işlev tarafından ptr_fun birli ve ikili işlev işaretçilerinin dönüştürülmesi, işlev bağdaştırıcılarının birli ve ikili işlev işaretçileriyle çalışmasını sağlar.

Örnek

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

Bağımsız değişkenden bir reference_wrapper oluşturur.

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

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

Dönüş Değeri

için bir başvuru arg; özellikle, reference_wrapper<Ty>(arg).

Örnek

Aşağıdaki örnek iki işlevi tanımlar: biri bir dize değişkenine, diğeri çağrısı tarafından hesaplanan dize değişkeninin başvurusuna refbağlı. Değişkenin değeri değiştiğinde, ilk işlev eski değeri kullanmaya devam eder ve ikinci işlev yeni değeri kullanır.

#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

İki function nesneyi değiştirir.

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

Parametreler

FT
İşlev nesneleri tarafından denetlenen tür.

f1
İlk işlev nesnesi.

f2
İkinci işlev nesnesi.

Açıklamalar

işlevi döndürür f1.swap(f2).

Örnek

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