参数归纳与标准::变体

Parameter induction with std::variant

本文关键字：变体 标准 参数      更新时间：2023-10-16

最近我正在研究一个ORM，它通过执行以下操作来接受函数注册：

orm->register_func("NAME", &User::set_name);

所以基本上当数据库返回列NAME时，ORM会使用User中的函数set_name。在开发过程中，我学到了更多关于std::variant的知识，这里有一个小例子来说明我如何使用它：

template<typename RET, typename T, typename ...Args>
using FPTR = RET(T::*)(Args...);
template<typename T>
using VARIANT_FPTR = std::variant<FPTR<void, T, const char *>, FPTR<void, T, const unsigned int>, long int>;

FPTR基本上是一个泛型函数指针(假设该函数是一个类成员(，VARIANT_FPTR定义了我可以在ORM中注册的函数的可能性。

现在，由于std::variant类型，我遇到了问题。以下是register_func实现：

void register_func(std::string name, VARIANT_FPTR<T> ptr)
{
_map.insert(std::make_pair(name, ptr));
}

但是，我收到编译错误，因为像&User::set_name这样的参数不是std::variant类型。

有没有办法让register_func诱导其参数的类型？ 如果没有，有没有另一种方法可以进行类似的过程？

编译错误为：

error: cannot convert ‘<unresolved overloaded function type>’ to ‘VARIANT_FPTR<services::User>’ {aka ‘std::variant<void (services::User::*)(const char*), void (services::User::*)(unsigned int), long int>’}

下面是映射定义：

template<typename T>  class Orm
{
private:
std::map<std::string, VARIANT_FPTR<T>> _map;
// ...
};

您需要在std::map模板的实例化中提供确切的类型。例如，如果需要User的成员函数，则需要以下内容：

std::map<std::string, VARIANT_FPTR<User>> _map;
//                                 ^^^^^

下面是一个完整的最小工作示例：在线观看直播

#include <iostream>
#include <variant>
#include <string>
#include <map>
struct User
{
template<typename T>
void set_name(T)
{}
};
template<typename RET, typename T, typename ...Args>
using FPTR = RET(T::*)(Args...);
template<typename T>
using VARIANT_FPTR = std::variant<FPTR<void, T, const char*>, FPTR<void, T, const unsigned int>, long int>;

template<typename T> class Orm
{
private:
std::map<std::string, VARIANT_FPTR<T>> _map;
public:
void register_func(std::string name, VARIANT_FPTR<User> ptr)
{
_map.emplace(name, ptr);
}
};
int main()
{
Orm<User> orm{};
orm.register_func("NAME", &User::set_name<const char*>);
orm.register_func("NAME", &User::set_name<const unsigned int>);
return 0;
}

问题(假设编译器正确说所讨论的成员函数已重载(是std::variant<X,Y>没有构造函数接受X和Y。相反，它有一个构造函数模板，该模板执行重载解析以确定要构造的替代项。 该模板无法推断从指针(或指向成员的指针(到重载集的未知成员的简单T。 如果只有一个重载适合任何变体的选择，您可以自己提供这些重载：

template<class T>
auto pick(FPTR<void, T, const char *> f) {return f;}
auto pick(FPTR<void, T, const unsigned int> f) {return f;}
/* elsewhere */ {
orm->register_func("NAME", pick(&User::set_name));
}

如果这仍然不明确，您可以使用static_cast来选择重载：

orm->register_func
("NAME",
static_cast<FPTR<void, T, const char *>>
(&User::set_name));

显然，在这种棘手的情况下，使用 std：：variant 进行参数归纳并不总是可行的。因此，为了解决这个问题，我最终决定使寄存器函数的使用更加冗长。在这里：

template<typename RES, typename CLASS, typename ...Args>
void register_func(std::string name, FPTR<RES, CLASS, Args...> ptr) {
_map.insert(std::make_pair(name, ptr));
}

因此，要使用它，您需要编写：

orm->register_func<void, Class, const char *>("name", &Class::set_name);

有趣的事实

我发现在某些情况下，某些参数实际上可以归纳。在以下函数的情况下：

void Class::set_id(unsigned long id)

我显然可以这样称呼register_function：

orm->register_func("id", &Class::set_id);
相关文章：