web-dev-qa-db-ja.com

無料の関数が期待される場所でメンバー関数を渡すにはどうすればよいですか？

質問は次のとおりです。このコードを検討してください。

#include <iostream>


class aClass
{
public:
    void aTest(int a, int b)
    {
        printf("%d + %d = %d", a, b, a + b);
    }
};

void function1(void (*function)(int, int))
{
    function(1, 1);
}

void test(int a,int b)
{
    printf("%d - %d = %d", a , b , a - b);
}

int main (int argc, const char* argv[])
{
    aClass a();

    function1(&test);
    function1(&aClass::aTest); // <-- How should I point to a's aClass::test function?

    return 0;
}

aのaClass::testをfunction1の引数として使用するにはどうすればよいですか？私はこれを行うことにこだわっています。

クラスのメンバーにアクセスしたいです。

c++argumentsparameter-passingfunction-pointerspointer-to-member
95
Jorge Leitão

関数ポインターを使用しても何も問題はありません。ただし、非静的メンバー関数へのポインターは、通常の関数ポインターとは異なります。メンバー関数は、関数への暗黙的な引数として渡されるオブジェクトで呼び出す必要があります。上記のメンバー関数のシグネチャは次のとおりです。

void (aClass::*)(int, int)

使用しようとするタイプではなく

void (*)(int, int)

1つの方法は、メンバー関数staticを作成することです。この場合、オブジェクトを呼び出す必要はなく、タイプvoid (*)(int, int)で使用できます。

クラスの非静的メンバーにアクセスする必要がある場合andたとえば、関数がCインターフェイスの一部であるため、関数ポインタを使用する必要がある場合、常にvoid*を渡すことが最善のオプションです関数へのポインタを取得する関数への転送、およびvoid*からオブジェクトを取得してメンバー関数を呼び出す転送関数を介してメンバーを呼び出します。

適切なC++インターフェイスで、関数が任意のクラス型を使用するために関数オブジェクトのテンプレート引数を取るようにしたい場合があります。テンプレート化されたインターフェイスの使用が望ましくない場合は、std::function<void(int, int)>のようなものを使用する必要があります。たとえば、std::bind()を使用して、これらに対して適切に呼び出し可能な関数オブジェクトを作成できます。

クラス型のテンプレート引数または適切なstd::function<...>を使用するタイプセーフなアプローチは、void*インターフェイスを使用するよりも、誤ったタイプへのキャストによるエラーの可能性を排除するため、望ましい方法です。

関数ポインターを使用してメンバー関数を呼び出す方法を明確にするために、以下に例を示します。

// the function using the function pointers:
void somefunction(void (*fptr)(void*, int, int), void* context) {
    fptr(context, 17, 42);
}

void non_member(void*, int i0, int i1) {
    std::cout << "I don't need any context! i0=" << i0 << " i1=" << i1 << "\n";
}

struct foo {
    void member(int i0, int i1) {
        std::cout << "member function: this=" << this << " i0=" << i0 << " i1=" << i1 << "\n";
    }
};

void forwarder(void* context, int i0, int i1) {
    static_cast<foo*>(context)->member(i0, i1);
}

int main() {
    somefunction(&non_member, 0);
    foo object;
    somefunction(&forwarder, &object);
}
113
Dietmar Kühl

@Pete Beckerの答えは問題ありませんが、C++ 11のfunction1に明示的なパラメーターとしてclassインスタンスを渡すことなく行うこともできます。

#include <functional>
using namespace std::placeholders;

void function1(std::function<void(int, int)> fun)
{
    fun(1, 1);
}

int main (int argc, const char * argv[])
{
   ...

   aClass a;
   auto fp = std::bind(&aClass::test, a, _1, _2);
   function1(fp);

   return 0;
}
65
Matt Phillips

メンバー関数へのポインターは、関数へのポインターとは異なります。ポインターを介してメンバー関数を使用するには、そのポインター（明らかに）とそれを適用するオブジェクトが必要です。したがって、function1の適切なバージョンは

void function1(void (aClass::*function)(int, int), aClass& a) {
    (a.*function)(1, 1);
}

そしてそれを呼び出すには：

aClass a; // note: no parentheses; with parentheses it's a function declaration
function1(&aClass::test, a);
39
Pete Becker

2011年以降、function1を変更できる場合は、次のように変更してください。

#include <functional>
#include <cstdio>

using namespace std;

class aClass
{
public:
    void aTest(int a, int b)
    {
        printf("%d + %d = %d", a, b, a + b);
    }
};

template <typename Callable>
void function1(Callable f)
{
    f(1, 1);
}

void test(int a,int b)
{
    printf("%d - %d = %d", a , b , a - b);
}

int main()
{
    aClass obj;

    // Free function
    function1(&test);

    // Bound member function
    using namespace std::placeholders;
    function1(std::bind(&aClass::aTest, obj, _1, _2));

    // Lambda
    function1([&](int a, int b) {
        obj.aTest(a, b);
    });
}

（ ライブデモ ）

また、壊れたオブジェクト定義を修正したことに注意してください（aClass a();は関数を宣言します）。

3
Lightness Races in Orbit

私は同様の質問をしました（ C++ openframeworks passing void from other classes ）しかし、私が見つけた答えはより明確だったので、ここで将来の記録の説明：

次のようにstd :: functionを使用する方が簡単です：

 void draw(int grid, std::function<void()> element)

そして、次のように呼び出します：

 grid.draw(12, std::bind(&BarrettaClass::draw, a, std::placeholders::_1));

またはさらに簡単：

  grid.draw(12, [&]{a.draw()});

参照によってキャプチャするオブジェクトを呼び出すラムダを作成する場所

1
Nicola Bertelloni

頭を叩くのを止めることができます。ここに、引数としてプレーンC関数を受け取るexisting関数をサポートするメンバー関数のラッパーを示します。ここでは、thread_localディレクティブが重要です。

http://cpp.sh/9jhk

// Example program
#include <iostream>
#include <string>

using namespace std;

typedef int FooCooker_ (int);

// Existing function
extern "C" void cook_10_foo (FooCooker_ FooCooker) {
    cout << "Cooking 10 Foo ..." << endl;
    cout << "FooCooker:" << endl;
    FooCooker (10);
}

struct Bar_ {
    Bar_ (int Foo = 0) : Foo (Foo) {};
    int cook (int Foo) {
        cout << "This Bar got " << this->Foo << endl;
        if (this->Foo >= Foo) {
            this->Foo -= Foo;
            cout << Foo << " cooked" << endl;
            return Foo;
        } else {
            cout << "Can't cook " <<  Foo << endl;
            return 0;
        }
    }
    int Foo = 0;
};

// Each Bar_ object and a member function need to define
// their own wrapper with a global thread_local object ptr
// to be called as a plain C function.
thread_local static Bar_* BarPtr = NULL;
static int cook_in_Bar (int Foo) {
    return BarPtr->cook (Foo);
}

thread_local static Bar_* Bar2Ptr = NULL;
static int cook_in_Bar2 (int Foo) {
    return Bar2Ptr->cook (Foo);
}

int main () {
  BarPtr = new Bar_ (20);
  cook_10_foo (cook_in_Bar);

  Bar2Ptr = new Bar_ (40);
  cook_10_foo (cook_in_Bar2);

  delete BarPtr;
  delete Bar2Ptr;
  return 0;
}

このアプローチの問題についてコメントしてください。

他の答えは、呼び出しに失敗しますexistingプレーンC関数： http://cpp.sh/8exun

0
Necktwi

メンバー関数を静的として作成し、すべて機能します：

#include <iostream>

class aClass
{
public:
    static void aTest(int a, int b)
    {
        printf("%d + %d = %d\n", a, b, a + b);
    }
};

void function1(int a,int b,void function(int, int))
{
    function(a, b);
}

void test(int a,int b)
{
    printf("%d - %d = %d\n", a , b , a - b);
}

int main (int argc, const char* argv[])
{
    aClass a;

    function1(10,12,test);
    function1(10,12,a.aTest); // <-- How should I point to a's aClass::test function?

    getchar();return 0;
}
0
mathengineer