メンバー関数ポインターを関数ポインターに合法的にキャストできますか？

私はいくつかのC ++コードを継承し、警告を取り除くという任務を負っています。

ここでは、メンバー関数ポインターが関数ポインターにキャストされています。メンバー関数ポインターは、内部に暗黙の「this」パラメーターが含まれているという点で、関数ポインターとは「異なる」ことを理解しています。ただし、私の前任者は、メンバー関数ポインターから、追加の最初のパラメーターが挿入された関数ポインターにキャストすることにより、この事実を明示的に利用したようです。

私の質問は次のとおりです。

A）コンパイラの警告を取り除くことはできますか？

B）このコードはどの程度機能することが保証されていますか？

この質問の目的のために、私はそれを小さなmain.cppに切り詰めました：

#define GENERIC_FUNC_TYPE   void(*)(void)
#define FUNC_TYPE       int(*)(void *)

class MyClass
{
public:
    MyClass(int a) : memberA(a) {}
    int myMemberFunc()
    {
        return memberA;
    }

private:
    int memberA;
};

int main(int argc, char*argv[])
{
    int (MyClass::* memberFunc) () = &MyClass::myMemberFunc;
    MyClass myObject(1);
    std::cout << (myObject.*memberFunc)() << std::endl;
    // All good so far

    // Now get naughty, store it away in a very basic fn ptr
    void(*myStoredFunction)(void) = (GENERIC_FUNC_TYPE)memberFunc;  // Compiler warning

    // Reinterpret the fn pointer as a pointer to fn, with an extra object parameter
    int (*myExtractedFunction)(void*) = (FUNC_TYPE)myStoredFunction;

    // Call it
    std::cout << myExtractedFunction(&myObject) << std::endl;
}

コードはg ++で1つの警告とともにコンパイルされ、意図したとおりに2つの1が出力されます。

main.cpp: In function ‘int main(int, char**)’:
main.cpp:27:53: warning: converting from ‘int (MyClass::*)()’ to ‘void (*)()’ [-Wpmf-conversions]
  void(*myStoredFunction)(void) = (GENERIC_FUNC_TYPE)memberFunc; // Compiler warning
                                                     ^

私見このコードは、コンパイラの基礎となるメカニズムについて仮定しています。あるいは、これらの仮定はすべてのC ++コンパイラに有効かもしれません-誰か助けてもらえますか？

（実際のコードでは、マップに名前で関数ポインターの束全体を格納しています。これらの関数はすべて異なるシグネチャを持っているため、すべて同じシグネチャvoid（*）（void）にキャストされます。これは類似しています。上記のmyStoredFunctionに追加されます。次に、上記のmyExtractedFunctionと同様に、呼び出し時に個々の署名にキャストされます。）

キャストを完全に回避する関数を作成するのはどうですか？

template <typename C, void (C::*M)()>
void AsFunc(void* p)
{
    (static_cast<C*>(p)->*M)();
}

その後

void(*myStoredFunction)(void) = &AsFunc<MyClass, &MyClass::myMemberFunc>;

C ++ 17では、いくつかの特徴がtemplate <auto *M> void AsFunc(void* p)あり、void(*myStoredFunction)(void) = &AsFunc<&MyClass::myMemberFunc>;

タイトルの質問に答えるために、いいえ、メンバー関数へのポインターを関数へのポインターに合法的にキャストすることはできません。おそらく、それはそのキャストとの行の「コンパイラ警告」が言ったことです。

不適合なコード（少し単純化されすぎています）に直面したときに診断を発行するには、適合コンパイラーが必要ですが、これはそうしました。警告を出しました。これを実行すると、コンパイラーは実装固有の処理を自由に実行できます。これは、実行したように見えます。つまり、コードをコンパイルして、期待どおりの処理を実行します。

コンパイラーは、機能する任意の方法でメンバー関数へのポインターを自由に表すことができます。非仮想関数の場合、それは関数への単なる「通常の」ポインターである可能性があります。しかし、仮想関数でそれを試してください。結果はもっと厳しいに違いない。

A）コンパイラの警告を取り除くことはできますか？

はい-静的関数からの呼び出しでメンバー関数をラップします

（これは@ Jarod42のテンプレートベースの回答のローテクバリアントです）

B）このコードはどの程度機能することが保証されていますか？

そうではありません（@Pete Beckerの答えを要約します）。警告を取り除くまで。

これが私たちが行ったものの要点です。コードの中断を最小限に抑えるために、シンプルに保ちました。コードで作業できる人の数を最大化するために、高度なC ++機能を避けました。

#include <iostream>

class MyClass
{
public:
    MyClass(int a) : memberA(a) {}
    static int myMemberFuncStatic(MyClass *obj)
    {
        return obj->myMemberFunc();
    }   
    int myMemberFunc()
    {
        return memberA;
    }

private:
    int memberA;
};

typedef void(*GENERIC_FUNC_TYPE)(void);
typedef int(*FUNC_TYPE)(MyClass *);

int main(int argc, char*argv[])
{
    int (* staticFunc) (MyClass *) = &MyClass::myMemberFuncStatic;
    MyClass myObject(1);
    std::cout << staticFunc(&myObject) << std::endl;
    // All good so far

    // This is actually legal, for non-member functions (like static functions)
    GENERIC_FUNC_TYPE myStoredFunction = reinterpret_cast<GENERIC_FUNC_TYPE> (staticFunc);  // No compiler warning

    // Reinterpret the fn pointer as the static function
    int (*myExtractedFunction)(MyClass*) = (FUNC_TYPE)myStoredFunction;

    // Call it
    std::cout << myExtractedFunction(&myObject) << std::endl;
}

関数void*ごとに異なるいくつかの引数を渡しながら、「型指定されていない」オブジェクト（）で名前で関数を呼び出す必要があるように見えるため、何らかの多重ディスパッチが必要です。考えられる解決策は次のとおりです。

#include <string>
#include <iostream>
#include <stdexcept>
#include <functional>
#include <utility>
#include <map>

template <typename Subj>
using FunctionMap = std::map<std::string, std::function<void (Subj&, const std::string&)>>;

class AbstractBaseSubject {
    public:
        virtual void invoke (const std::string& fName, const std::string& arg) = 0;
};

template <typename Class>
class BaseSubject : public AbstractBaseSubject {
    public:
        virtual void invoke (const std::string& fName, const std::string& arg) {
            const FunctionMap<Class>& m = Class::functionMap;

            auto iter = m.find (fName);
            if (iter == m.end ())
                throw std::invalid_argument ("Unknown function \"" + fName + "\"");

            iter->second (*static_cast<Class*> (this), arg);
        }
};

class Cat : public BaseSubject<Cat> {
    public:
        Cat (const std::string& name) : name(name) {}
        void meow (const std::string& arg) {
            std::cout << "Cat(" << name << "): meow (" << arg << ")\n";
        }

        static const FunctionMap<Cat> functionMap;
    private:
        std::string name;
};

const FunctionMap<Cat> Cat::functionMap = {
    { "meow", [] (Cat& cat, const std::string& arg) { cat.meow (arg);  } }
};

class Dog : public BaseSubject<Dog> {
    public:
        Dog (int age) : age(age) {}
        void bark (float arg) {
            std::cout << "Dog(" << age << "): bark (" << arg << ")\n";
        }

        static const FunctionMap<Dog> functionMap;
    private:
        int age;
};

const FunctionMap<Dog> Dog::functionMap = {
    { "bark", [] (Dog& dog, const std::string& arg) { dog.bark (std::stof (arg));  }}
};

int main () {
    Cat cat ("Mr. Snuggles");
    Dog dog (7);

    AbstractBaseSubject& abstractDog = dog;     // Just to demonstrate that the calls work from the base class.
    AbstractBaseSubject& abstractCat = cat;

    abstractCat.invoke ("meow", "Please feed me");
    abstractDog.invoke ("bark", "3.14");

    try {
        abstractCat.invoke ("bark", "3.14");
    } catch (const std::invalid_argument& ex) {
        std::cerr << ex.what () << std::endl;
    }
    try {
        abstractCat.invoke ("quack", "3.14");
    } catch (const std::invalid_argument& ex) {
        std::cerr << ex.what () << std::endl;
    }
    try {
        abstractDog.invoke ("bark", "This is not a number");
    } catch (const std::invalid_argument& ex) {
        std::cerr << ex.what () << std::endl;
    }
}

ここで、この方法で呼び出される関数を持つすべてのクラスBaseSubjectは、派生する必要があります（これはCRTPです）。これらの（ここでは、クラスCatとDog、のは、「科目」、それらを呼びましょう）が異なる引数と異なる機能を持っている（barkとmeow-もちろん、被写体ごとに複数の機能が可能です）。各サブジェクトには、独自mapの文字列から関数までがあります。これらの関数は関数ポインタではなく、std::function<void (SubjectType&,const std::string&)>インスタンスです。それらのそれぞれは、必要な引数を渡して、オブジェクトのそれぞれのメンバー関数を呼び出す必要があります。引数は、ある種の一般的なデータ表現から取得する必要がありstd::stringます。ここでは、単純なを選択しました。データの出所に応じて、JSONまたはXMLオブジェクトの場合があります。std::functionインスタンスは、データをデシリアライズし、引数として渡す必要があります。map作成されたstatic各対象クラス内の変数、std::functionインスタンスはラムダが取り込まれています。BaseSubjectクラスは見上げfunctionインスタンスをし、それを呼び出します。サブジェクトクラスは常にから直接派生する必要があるため、BaseSubject<Subject>型のポインタはBaseSubject<Subject>*直接かつ安全ににキャストできSubject*ます。

安全でないキャストはまったくないことに注意してください。すべて仮想関数によって処理されます。したがって、これは完全にポータブルである必要があります。mapサブジェクトクラスごとに1つ持つと入力が集中しますが、異なるクラスで同じ名前の関数を使用できます。とにかく、関数ごとに個別に何らかのデータのアンパックが必要なため、内に個別のアンパックラムダがありmapます。

関数の引数が単なる抽象データ構造である場合、つまりconst std::string&、ラムダを省略して次のようにすることができます。

const FunctionMap<Cat> Cat::functionMap = {
    { "meow", &Cat::meow }
};

これは、関数ポインタとは対照的に、明確に定義され、許可されているstd::function魔法（this最初の引数を介して渡す）によって機能します。これは、すべての関数が同じ署名を持っている場合に特に役立ちます。実際、std::functionJarod42の提案を省略してプラグインすることもできます。

PS：楽しみのために、member-function-pointerをfunction-pointerにキャストできない例を次に示します。

#include <iostream>

struct A {
    char x;
    A () : x('A') {}
    void foo () {
        std::cout << "A::foo() x=" << x << std::endl;
    }
};

struct B {
    char x;
    B () : x('B') {}
    void foo () {
        std::cout << "B::foo() x=" << x << std::endl;
    }
};

struct X : A, B {
};

int main () {
    void (B::*memPtr) () = &B::foo;
    void (*funPtr) (X*) = reinterpret_cast<void (*)(X*)> (memPtr);  // Illegal!

    X x;
    (x.*memPtr) ();
    funPtr (&x);
}

私のマシンでは、これは次のように出力します。

B::foo() x=B
B::foo() x=A

Bこのクラスは、「X = A」を印刷することができないはず！これは、this多重継承が機能する場合に備えて、メンバー関数ポインターが呼び出しの前に追加される追加のオフセットを運ぶために発生します。キャストはこのオフセットを失います。したがって、キャストされた関数ポインタを呼び出すと、はthis自動的に最初のベースオブジェクトを参照し、Bが2番目のオブジェクトを参照して、間違った値を出力します。

PPS：さらに楽しく：Jarod42の提案をプラグインすると：

template <typename C, void (C::*M)(), typename Obj>
void AsFunc (Obj* p) {
    (p->*M)();
}

int main () {
    void (*funPtr) (X*) = AsFunc<B, &B::foo, X>;

    X x;
    funPtr (&x);
}

プログラムは正しく印刷します：

B::foo() x=B

の逆アセンブルを見ると、次のようになりAsFuncます。

c90 <void AsFunc<B, &B::foo, X>(X*)>:
 c90:   48 83 c7 01             add    $0x1,%rdi
 c94:   e9 07 ff ff ff          jmpq   ba0 <B::foo()>

コンパイラは1、thisポインタに追加するコードを自動的に生成しました。このコードB::fooはthis、のB基本クラスを指すように呼び出されXます。これはで実現するためにAsFunc（内に埋め込まに反対機能main）、私は導入Objすることができますテンプレートパラメータp引数は派生型でもX、このようなAsFunc追加を行う必要があります。