不明な（コンパイル時に）戻り値の型を持つ関数へのポインタを宣言することは可能ですか？質問する

Question

あ差別された組合あなたのためにそれを行うことができます：

class A
{
  template<T>
  using cb_type = T(double);

  protected:
     enum {IS_INT, IS_DOUBLE} cb_tag;
     union {
       cb_type<int>    *ptrToIntFunction;
       cb_type<double> *ptrToDoubleFunction;
     };

  public:
  ...
  // Setting function according to its name
  void SetPtrToFunction( std::string fName );
};

std::variant判別共用体に対するより一般的でエレガントなソリューションは、C++17 またはboost::variantそれ以前の標準リビジョンで適用できます。

あるいは、戻り値の型を完全に無視したい場合は、メンバーを次のように変換することができます。std::function<void(double)>型消去のメリットを享受できます。このCallable概念では、ポインター経由の呼び出しが変換されstatic_cast<void>(INVOKE(...))、戻り値が何であれ、その戻り値が破棄されます。

に例示する:

#include <functional>
#include <iostream>

int foo(double d)  { std::cout << d << '\n'; return 0; }

char bar(double d) { std::cout << 2*d << '\n'; return '0'; }

int main() {
    std::function<void(double)> cb;

    cb = foo; cb(1.0);

    cb = bar; cb(2.0);

    return 0;
}

そして最後に、もしあなたが気にする戻り値について知りたいが、店判別されたユニオン。ユニオンとの動作について理解すればstd::function、上記の 2 つのアプローチを組み合わせることができます。

このような

#include <functional>
#include <iostream>
#include <cassert>

int    foo(double d) { return d; }

double bar(double d) { return 2*d; }

struct Result {
    union {
        int    i_res;
        double d_res;
    };
    enum { IS_INT, IS_DOUBLE } u_tag;

    Result(Result const&) = default;
    Result(int i)  : i_res{i}, u_tag{IS_INT} {}
    Result(double d) : d_res{d}, u_tag{IS_DOUBLE} {}

    Result& operator=(Result const&) = default;
    auto& operator=(int i)
    { i_res = i; u_tag = IS_INT;    return *this; }
    auto& operator=(double d)
    { d_res = d; u_tag = IS_DOUBLE; return *this; }
};

int main() {
    std::function<Result(double)> cb;

    cb = foo;
    auto r = cb(1.0);
    assert(r.u_tag == Result::IS_INT);
    std::cout << r.i_res << '\n';

    cb = bar;
    r = cb(2.0);
    assert(r.u_tag == Result::IS_DOUBLE); 
    std::cout << r.d_res << '\n';

    return 0;
}

Answer 1