是否可以为类似 std::any 的容器转发具有匹配模板类型的函数调用？

Question

我还没有找到一种方法来实现我想要的，但我的知识不足以知道它是否不可能。帮助将不胜感激。

我们软件中的主要数据数据容器的行为有点像 std::variant 或 std::any：它有一个基础 class BaseContainer 提供类型枚举。派生实例 DataContainer 将实际数据保存在类型张量成员变量中。所以一个简化的例子可以归结为这样的：

BaseContainer* vContainer = new DataContainer<float>({1000000});
if (vContainer->getType() == DataTypes::FLOAT)
    const Tensor<float>& vTensor = dynamic_cast<DataContainer<float>>(vContainer)->getData();

我们有许多方法可以根据底层模板化类型和维度处理数据：

template<typename T>
void processData(const tensor<T>& aTensor, ...other arguments...);

问题是，对于我们想要用 BaseContainer 调用的每个方法，例如 processData()，我们需要编写一个绑定方法来解开可能的类型，以调用类型化版本的 processData():

void processData(BaseContainer* aContainer) {
    switch (vContainer->getType()) {
        case DataTypes::INT8:
            return processData(dynamic_cast<DataContainer<int8_t>>(vContainer)->getData());
        case DataTypes::UINT8:
            return processData(dynamic_cast<DataContainer<uint8_t>>(vContainer)->getData());
        case DataTypes::INT16:
            return processData(dynamic_cast<DataContainer<int16_t>>(vContainer)->getData());
        case DataTypes::UINT16:
            return processData(dynamic_cast<DataContainer<uint16_t>>(vContainer)->getData());
...
        default:
            throw(std::runtime_error("Type not supported"));
    }
}

我的问题是：是否有可能制作一个单一的“适配器”方法（在任何已发布的 c++ 版本中），它可以接受一个函数（如 processData()）、一个 BaseContainer 和一个可能的参数列表, 并使用参数调用此函数的正确模板绑定?

我未能动态绑定模板函数，因为我无法在没有模板类型的情况下传递名称。然而，模板类型需要基于 BaseContainer 是动态的。但也许还有其他方法可以实现我想做的事情？我对任何解决方案都很好奇，主要也是为了扩展我的理解，只要解决方案的复杂性低于编写数百个适配器方法即可。

如果不出意外，是否可以使用预处理器宏生成“适配器”方法？

Answer 1

如果您愿意为每个 processData 类函数编写一个小包装器 class，您可以这样做：

// One like this for each function.
struct ProcessDataWrapper {
  template <typename... Args>
  static auto run(Args&&... args) {
    return processData(std::forward<Args>(args)...);
  }
};

template <typename Wrapper>
auto ProcessGeneric(BaseContainer* aContainer) {
    switch (vContainer->getType()) {
        case DataTypes::INT8:
            return Wrapper::run(dynamic_cast<DataContainer<int8_t>>(vContainer)->getData());
    // ...
}

// Called as
ProcessGeneric<ProcessDataWrapper>(myContainer);

Answer 2

有可能，但正如评论所说，可能值得考虑 std::visit。

这是一个需要 c++17 的解决方案，它只需要两行来表示您要包装的每个函数模板。您可以使用一个简单的宏来进一步简化包装。

核心思想是有一个 cast 函数从 DataType 枚举映射到相应的 DataContainer 然后利用 c++17 折叠表达式来包装开关在您的代码中声明。

这是 cast 函数，所以我们只有一个地方可以从 DataType 映射到实际的 DataContainer:

template<DataType t>
constexpr inline decltype(auto) cast(BaseContainer& c) {
    if constexpr(t == INT) return static_cast<DataContainer<int>&>(c);
    else if constexpr(t == FLOAT) return static_cast<DataContainer<float>&>(c);
    ... map all other enum values ...
}

这是一个方便的助手，可以使下面的代码更具可读性。下一个代码块使用 c++17 折叠表达式根据容器的类型调度函数。

template<DataType... types>
auto dispatcher_impl = [](auto f) {
    // NB: capture by value here only for sake of readbility. 
    return [=](BaseContainer& c, auto... args) {
        ([&]{ if(c.GetDataType() == types ) {  std::invoke(f, cast<types>(c), args...); return true; } return false; }() || ...);
    };
};

auto data_type_dispatcher = [](auto f) {
    return dispatcher_impl<INT, FLOAT, ... other types here ...>(f);
};

核心思想是将函数包装到一个 lambda 中，该 lambda 检查 DataContainer 的数据类型并仅在匹配时调用该函数。 || 运算符上的折叠表达式用于解压缩 DataTypes.

用法示例：

template<typename T>
void processData(DataContainer<T>& c, int arg) {
    if constexpr(std::is_same_v<T, int>) std::cout << "int";
    else if constexpr(std::is_same_v<T, float>) std::cout << "float";
    std::cout << ", arg: " << arg << '\n';
}

// 每个函数都需要这样做： auto pd = data_type_dispatcher([](auto& c, int arg) { processData(c, arg); });

int main() {

    DataContainer<float> f;
    DataContainer<int> i;
    pd(f, 2); // prints float, 2
    pd(i, 4); // prints int, 4
}

完整示例 here.

为了在类型不受支持时抛出异常，只需在折叠表达式的末尾添加一个抛出的 lambda：

    ([&]{ if(c.GetDataType() == types ) {  std::invoke(f, cast<types>(c), args...); return true; } return false; }() || ...  || []() -> bool{ throw (std::runtime_error("Type not supported")); }());
                                                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Answer 3

您不能按名称传递重载，但您可以像通用 lambda 那样传递带有重载 operator() 的仿函数。

所以

template <typename F>
auto dispatch(BaseContainer& vContainer, F f) {
    switch (vContainer.getType()) {
        case DataTypes::INT8:
            return f(dynamic_cast<DataContainer<int8_t>&>(vContainer).getData());
        case DataTypes::UINT8:
            return f(dynamic_cast<DataContainer<uint8_t>&>(vContainer).getData());
        case DataTypes::INT16:
            return f(dynamic_cast<DataContainer<int16_t>&>(vContainer).getData());
        case DataTypes::UINT16:
            return f(dynamic_cast<DataContainer<uint16_t>&>(vContainer).getData());
...
        default:
            throw (std::runtime_error("Type not supported"));
    }
}

有使用

dispatch(vContainer, [](auto* data){ return processData(data); });

是否可以为类似 std::any 的容器转发具有匹配模板类型的函数调用？

Is it possible to forward function calls with matching template type for a std::any-like container?

c++

templates

design-patterns

stdbind

stdany