是否可以声明指向未知(编译时）返回类型的函数的指针

Is it possible to declare a pointer to a function with unknown (at compile time) return type

本文关键字：返回类型 编译 函数 指针 声明 未知 是否      更新时间：2023-10-16

我有一个class A，我想在其中有一个指向函数作为数据成员的指针：

class A
{
protected:
double (*ptrToFunction) ( double );
public:
...
//Setting function according to its name
void SetPtrToFunction( std::string fName );
};

但是，如果我希望ptrToFunction有时是double的，有时是 -int，有这样的东西呢：

//T is a typename
T(*ptrToFunction) ( double );

在这种情况下，我应该如何声明它？

一个受歧视的工会可以为你做到这一点：

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

对于判别并集，可以应用C++17中的std::variant，也可以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的行为，就可以结合以上两种方法。

喜欢这个

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

如果您的类没有模板，如您的示例所示，您可以执行以下操作：

template <class T>
struct myStruct
{
static T (*ptrToFunction)(double);
};

看起来您正在使用dlsym/GetProcAddress来获取函数地址。

在这种情况下，您至少需要 2 个呼叫站点来消除呼叫的歧义，因为 CPU 实际上对每个调用执行不同的操作。

enum ReturnType { rtInt, rtDouble };
void SetPtrToFunction( std::string fName , enum ReturnType typeOfReturn );
struct Function {
enum ReturnType rt;
union {
std::function< int(double) > mIntFunction;
std::function< double(double) > mDoubleFunction;
} u;
} mFunction;

因此，该函数需要使用已知的返回类型进行实例化，然后将其与一些标记的联合一起使用以获得正确的函数调用。

int A::doCall( double value ) {
if( mFunction.rt == rtInt ) {
int result = mFunction.mIntFunction( value );
} else if( mFunction.rt == rtDouble ) {
double result = mFunction.mDoubleFunction( value );
}
}
相关文章：