function クラス

[アーティクル]
10/12/2023

呼び出し可能オブジェクトのラッパー。

構文

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

パラメーター

Fty
ラップする関数の型。

Ax
アロケーター関数。

解説

このクラステンプレートは、呼び出しシグネチャが Ret(T1, T2, ..., TN) である呼び出しラッパーです。これを使用して、さまざまな呼び出し可能オブジェクトを均一ラッパーで囲みます。

一部のメンバー関数は、目的のターゲットオブジェクトの名前を示すオペランドを取ります。その場合、オペランドは次のような方法で指定できます。

fn: 呼び出し可能なオブジェクト fn;呼び出し後、 function オブジェクトは次のコピーを保持します。 fn

fnref: fnref.get()によって名前が付けられた呼び出し可能なオブジェクト。呼び出しの後に、 function オブジェクトが fnref.get()

right: 呼び出し可能なオブジェクト (存在する場合) は、 function オブジェクトによって保持されます。 right

npc: null ポインター。呼び出しの後、 function オブジェクトが空です

いずれの場合も、INVOKE(f, t1, t2, ..., tN)f呼び出し可能なオブジェクトであり、t1, t2, ..., tNはそれぞれT1, T2, ..., TN型の左辺値であり、Retが無効でない場合は、Retに変換できる必要があります。

空の function オブジェクトは、呼び出し可能オブジェクトまたは呼び出し可能オブジェクトへの参照を保持しません。

メンバー

コンストラクター

名前	説明
function	空のラッパーまたは固定のシグネチャを持つ任意の型の呼び出し可能オブジェクトを格納するラッパーを作成します。

Typedefs

名前	説明
result_type	格納された呼び出し可能オブジェクトの戻り値の型。

関数

名前	説明
assign	呼び出し可能オブジェクトをこの関数オブジェクトに割り当てます。
スワップ	2 つの呼び出し可能オブジェクトを入れ替えます。
ターゲット	格納されている呼び出し可能オブジェクトが指定されたとおりに呼び出し可能かどうかをテストします。
target_type	呼び出し可能オブジェクトの型情報を取得します。

演算子

名前	説明
operator unspecified	格納されている呼び出し可能オブジェクトが存在するかどうかをテストします。
operator()	呼び出し可能オブジェクトを呼び出します。
operator=	格納されている呼び出し可能オブジェクトを置き換えます。

割り当て

呼び出し可能オブジェクトをこの関数オブジェクトに割り当てます。

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

パラメーター

_Func
呼び出し可能オブジェクト。

_Fnref
呼び出し可能オブジェクトを含む参照ラッパー。

Ax
アロケーターオブジェクト。

解説

各メンバー関数は、*this によって保持されている callable object を operand として渡される呼び出し可能オブジェクトに置き換えます。どちらもストレージとアロケーターオブジェクト Ax を割り当てます。

関数

空のラッパーまたは固定のシグネチャを持つ任意の型の呼び出し可能オブジェクトを格納するラッパーを作成します。

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

パラメーター

right
コピーする関数オブジェクト。

Fx
呼び出し可能オブジェクトの型。

_Func
ラップする呼び出し可能オブジェクト。

Alloc
アロケーター型。

Ax
アロケーター。

_Fnref
ラップする呼び出し可能オブジェクトの参照。

解説

最初の 2 つのコンストラクターは、空の function オブジェクトを構築します。次の 3 つのコンストラクターは、オペランドとして渡される呼び出し可能オブジェクトを保持する function オブジェクトを構築します。最後の 2 つのコンストラクターは、アロケーターオブジェクト Ax を使用してストレージを割り当てます。

例

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

格納されている呼び出し可能オブジェクトが存在するかどうかをテストします。

operator unspecified();

解説

この演算子は、オブジェクトが空でない場合にのみ、true 値を持つ bool に変換できる値を返します。その値を使用して、オブジェクトが空かどうかをテストします。

例

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

呼び出し可能オブジェクトを呼び出します。

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

パラメーター

TN
N 番目の引数の型。

tN
N 番目の呼び出しの引数。

解説

このメンバー関数は INVOKE(fn, t1, t2, ..., tN, Ret) を返します。ここで、fn は *this に保存されるターゲットオブジェクトです。それを使用してラップされた呼び出し可能オブジェクトを呼び出します。

例

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

格納されている呼び出し可能オブジェクトを置き換えます。

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

パラメーター

npc
null ポインターの定数。

right
コピーする関数オブジェクト。

fn
ラップする呼び出し可能オブジェクト。

fnref
ラップする呼び出し可能オブジェクトの参照。

解説

演算子はそれぞれ *this によって保持されている呼び出し可能オブジェクトを、オペランドとして渡された呼び出し可能オブジェクトに置き換えます。

例

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

格納された呼び出し可能オブジェクトの戻り値の型。

typedef Ret result_type;

解説

この typedef は、テンプレートの呼び出しシグネチャ内の型 Ret のシノニムです。それを使用して、ラップされた呼び出し可能オブジェクトの戻り値の型を特定します。

例

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

スワップ

2 つの呼び出し可能オブジェクトを入れ替えます。

void swap(function& right);

パラメーター

right
入れ替える関数オブジェクト。

解説

このメンバー関数は、*this と right の間でターゲットオブジェクトを入れ替えます。一定時間に実行し、例外をスローしません。

例

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

ターゲット

格納されている呼び出し可能オブジェクトが指定されたとおりに呼び出し可能かどうかをテストします。

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

パラメーター

Fty2
テスト対象の呼び出し可能オブジェクトの型。

解説

型 Fty2 は、引数の型 T1, T2, ..., TN と戻り値の型 Ret に対して呼び出し可能である必要があります。 target_type() == typeid(Fty2) の場合、メンバーテンプレート関数は、ターゲットオブジェクトのアドレスを返し、それ以外の場合は、0 を返します。

型 Fty2 は、引数の型T1, T2, ..., TNに対して呼び出し可能であり、戻り値の型Ret、それぞれFty2, T1, T2, ..., TN型の左辺値fn, t1, t2, ..., tN、INVOKE(fn, t1, t2, ..., tN)が整形式であり、Retがvoidでない場合は、Retに変換できます。

例

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

呼び出し可能オブジェクトの型情報を取得します。

const std::type_info& target_type() const;

解説

メンバー関数は、*this が空の場合、typeid(void) を返します。それ以外の場合 typeid(T) を返します。T はターゲットオブジェクトの型です。

例

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

次の方法で共有

function クラス

構文

パラメーター

解説

メンバー

コンストラクター

Typedefs

関数

演算子

割り当て

パラメーター

解説

関数

パラメーター

解説

例

operator unspecified

解説

例

operator()

パラメーター

解説

例

operator=

パラメーター

解説

例

result_type

解説

例

スワップ

パラメーター

解説

例

ターゲット

パラメーター

解説

例

target_type

解説

例

フィードバック

その他のリソース