kelas fungsi

Pembungkus untuk objek yang dapat dipanggil.

Sintaks

template <class Fty>
class function  // Fty of type Ret(T1, T2, ..., TN)
    : public unary_function<T1, Ret>       // when Fty is Ret(T1)
    : public binary_function<T1, T2, Ret>  // when Fty is Ret(T1, T2)
{
public:
    typedef Ret result_type;

    function();
    function(nullptr_t);
    function(const function& right);
    template <class Fty2>
        function(Fty2 fn);
    template <class Fty2, class Alloc>
        function(reference_wrapper<Fty2>, const Alloc& Ax);

    template <class Fty2, class Alloc>
        void assign(Fty2, const Alloc& Ax);
    template <class Fty2, class Alloc>
        void assign(reference_wrapper<Fty2>, const Alloc& Ax);
    function& operator=(nullptr_t);
    function& operator=(const function&);
    template <class Fty2>
        function& operator=(Fty2);
    template <class Fty2>
        function& operator=(reference_wrapper<Fty2>);

    void swap(function&);
    explicit operator bool() const;

    result_type operator()(T1, T2, ....., TN) const;
    const std::type_info& target_type() const;
    template <class Fty2>
        Fty2 *target();

    template <class Fty2>
        const Fty2 *target() const;

    template <class Fty2>
        void operator==(const Fty2&) const = delete;
    template <class Fty2>
        void operator!=(const Fty2&) const = delete;
};

Parameter

Fty
Jenis fungsi yang akan dibungkus.

Kapak
Fungsi alokator.

Keterangan

Templat kelas adalah pembungkus panggilan yang tanda tangan panggilannya adalah Ret(T1, T2, ..., TN). Anda menggunakannya untuk mengapit berbagai objek yang dapat dipanggil dalam pembungkus seragam.

Beberapa fungsi anggota mengambil operand yang menamai objek target yang diinginkan. Anda dapat menentukan operand seperti itu dengan beberapa cara:

fn: Objek fnyang dapat dipanggil ; setelah panggilan function objek menyimpan salinan fn

fnref: Objek yang dapat dipanggil bernama oleh fnref.get(); setelah panggilan function objek menyimpan referensi ke fnref.get()

right: Objek yang dapat dipanggil, jika ada, yang dipegang function oleh objek right

npc: Penunjuk null; setelah panggilan function objek kosong

Dalam semua kasus, INVOKE(f, t1, t2, ..., tN), di mana f adalah objek yang dapat dipanggil dan t1, t2, ..., tN merupakan lvalue jenis T1, T2, ..., TN masing-masing, harus terbentuk dengan baik dan, jika Ret tidak batal, dapat dikonversi ke Ret.

Objek kosong function tidak menyimpan objek yang dapat dipanggil atau referensi ke objek yang dapat dipanggil.

Anggota

Konstruktor

Typedefs

Fungsi

Operator

assign

Menetapkan objek yang dapat dipanggil ke objek fungsi ini.

template <class Fx, class Alloc>
    void assign(
        Fx _Func,
        const Alloc& Ax);

template <class Fx, class Alloc>
    void assign(
        reference_wrapper<Fx> _Fnref,
        const Alloc& Ax);

Parameter

_Func
Objek yang dapat dipanggil.

_Fnref
Pembungkus referensi yang berisi objek yang dapat dipanggil.

Kapak
Objek alokator.

Keterangan

Anggota berfungsi masing-masing mengganti yang dipegang callable object oleh *this dengan objek yang dapat dipanggil yang diteruskan sebagai operand. Keduanya mengalokasikan penyimpanan dengan Ax objek alokator.

fungsi

Membuat pembungkus yang kosong atau menyimpan objek jenis arbitrer yang dapat dipanggil dengan tanda tangan tetap.

function();
function(nullptr_t npc);
function(const function& right);
template <class Fx>
    function(Fx _Func);
template <class Fx>
    function(reference_wrapper<Fx> _Fnref);
template <class Fx, class Alloc>
    function(
        Fx _Func,
        const Alloc& Ax);

template <class Fx, class Alloc>
    function(
        reference_wrapper<Fx> _Fnref,
        const Alloc& Ax);

Parameter

right
Objek fungsi yang akan disalin.

Fx
Jenis objek yang dapat dipanggil.

_Func
Objek yang dapat dipanggil untuk dibungkus.

Alokasi
Jenis alokator.

Kapak
Alokator.

_Fnref
Referensi objek yang dapat dipanggil untuk dibungkus.

Keterangan

Dua konstruktor pertama membuat objek kosong function . Tiga konstruktor berikutnya membuat function objek yang menyimpan objek yang dapat dipanggil yang diteruskan sebagai operand. Dua konstruktor terakhir mengalokasikan penyimpanan dengan Ax objek alokator.

Contoh

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

int square(int val)
{
    return val * val;
}

class multiply_by
{
public:
    explicit multiply_by(const int n) : m_n(n) { }

    int operator()(const int x) const
    {
        return m_n * x;
    }

private:
    int m_n;
};

int main()
{
    typedef std::vector< std::function<int (int)> > vf_t;

    vf_t v;
    v.push_back(square);
    v.push_back(std::negate<int>());
    v.push_back(multiply_by(3));

    for (vf_t::const_iterator i = v.begin(); i != v.end(); ++i)
    {
        std::cout << (*i)(10) << std::endl;
    }

    std::function<int (int)> f = v[0];
    std::function<int (int)> g;

    if (f) {
        std::cout << "f is non-empty (correct)." << std::endl;
    } else {
        std::cout << "f is empty (can't happen)." << std::endl;
    }

    if (g) {
        std::cout << "g is non-empty (can't happen)." << std::endl;
    } else {
        std::cout << "g is empty (correct)." << std::endl;
    }

    return 0;
}

100
-10
30
f is non-empty (correct).
g is empty (correct).

operator tidak ditentukan

Pengujian jika ada objek yang dapat dipanggil yang disimpan.

operator unspecified();

Keterangan

Operator mengembalikan nilai yang dapat dikonversi ke bool dengan nilai true hanya jika objek tidak kosong. Anda menggunakannya untuk menguji apakah objek kosong.

Contoh

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

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

int main()
    {
    std::function<int (int)> fn0;
    std::cout << std::boolalpha << "not empty == " << (bool)fn0 << std::endl;

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

    return (0);
    }

not empty == false
not empty == true

operator()

Memanggil objek yang dapat dipanggil.

result_type operator()(
    T1 t1,
    T2 t2, ...,
    TN tN);

Parameter

TN
Jenis argumen panggilan Nth.

Tn
Argumen panggilan Nth.

Keterangan

Fungsi anggota mengembalikan INVOKE(fn, t1, t2, ..., tN, Ret), di mana fn adalah objek target yang disimpan di *this. Anda menggunakannya untuk memanggil objek yang dapat dipanggil yang dibungkus.

Contoh

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

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

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

    return (0);
    }

empty == false
val == -3

operator=

Menggantikan objek yang dapat dipanggil tersimpan.

function& operator=(null_ptr_type npc);
function& operator=(const function& right);
template <class Fty>
    function& operator=(Fty fn);
template <class Fty>
    function& operator=(reference_wrapper<Fty> fnref);

Parameter

Npc
Konstanta pointer null.

right
Objek fungsi yang akan disalin.

Fn
Objek yang dapat dipanggil untuk dibungkus.

fnref
Referensi objek yang dapat dipanggil untuk dibungkus.

Keterangan

Operator masing-masing mengganti objek yang dapat dipanggil dengan *this objek yang dapat dipanggil yang diteruskan sebagai operand.

Contoh

// std__functional__function_operator_as.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;
    fn1 = 0;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;

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

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

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

    return (0);
    }

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

result_type

Jenis pengembalian objek yang dapat dipanggil yang disimpan.

typedef Ret result_type;

Keterangan

Typedef adalah sinonim untuk jenis Ret dalam tanda tangan panggilan templat. Anda menggunakannya untuk menentukan jenis pengembalian objek yang dapat dipanggil yang dibungkus.

Contoh

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

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

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

    std::function<int (int)>::result_type val = fn1(3);
    std::cout << "val == " << val << std::endl;

    return (0);
    }

empty == false
val == -3

pertukaran

Tukar dua objek yang dapat dipanggil.

void swap(function& right);

Parameter

right
Objek fungsi yang akan ditukar.

Keterangan

Fungsi anggota menukar objek target antara *this dan ke kanan. Ini melakukannya dalam waktu konstan dan tidak melemparkan pengecualian.

Contoh

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

    fn0.swap(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

target

Pengujian jika objek yang dapat dipanggil tersimpan dapat dipanggil seperti yang ditentukan.

template <class Fty2>
    Fty2 *target();
template <class Fty2>
    const Fty2 *target() const;

Parameter

Fty2
Jenis objek yang dapat dipanggil target untuk diuji.

Keterangan

Jenis Fty2 harus dapat dipanggil untuk jenis T1, T2, ..., TN argumen dan jenis Retpengembalian . Jika target_type() == typeid(Fty2), fungsi templat anggota mengembalikan alamat objek target; jika tidak, fungsi tersebut mengembalikan 0.

Jenis Fty2 dapat dipanggil untuk jenis T1, T2, ..., TN argumen dan jenis Ret pengembalian jika, untuk lvalue fn, t1, t2, ..., tN jenis Fty2, T1, T2, ..., TN, masing-masing, INVOKE(fn, t1, t2, ..., tN) terbentuk dengan baik dan, jika Ret tidak void, dapat dikonversi ke Ret.

Contoh

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

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

int main()
    {
    typedef int (*Myfun)(int);
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "no target == " << (fn0.target<Myfun>() == 0) << std::endl;

    Myfun *fptr = fn0.target<Myfun>();
    std::cout << "val == " << (*fptr)(3) << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "no target == " << (fn1.target<Myfun>() == 0) << std::endl;

    return (0);
    }

empty == false
no target == false
val == -3
empty == true
no target == true

target_type

Mendapatkan informasi jenis pada objek yang dapat dipanggil.

const std::type_info& target_type() const;

Keterangan

Fungsi anggota mengembalikan typeid(void) jika *this kosong, jika tidak, fungsi tersebut mengembalikan typeid(T), di mana T adalah jenis objek target.

Contoh

// std__functional__function_target_type.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 << "type == " << fn0.target_type().name() << std::endl;

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

    return (0);
    }

empty == false
type == int (__cdecl*)(int)
empty == true
type == void