1

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

我们软件中的主要数据数据容器的行为有点像 std::variant 或 std::any：它有一个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...);

问题是，对于processData()我们想用 a 调用的每个方法BaseContainer，我们需要编写一个绑定方法来解开可能的类型以调用 的类型化版本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 是动态的。但也许还有其他方法可以实现我想做的事情？我对任何解决方案都非常好奇，主要也是为了扩展我的理解，只要解决方案的复杂度低于编写数百个适配器方法即可。

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

4

3 回答 3

1

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

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

核心思想是拥有一个从枚举cast映射到对应的函数，然后利用 c++17 折叠表达式将 switch 语句包装在代码中。DataTypeDataContainer

这是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 fold 表达式根据容器的类型分派函数。

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，它检查 DataContainer 的 DataType 并仅在匹配时调用该函数。运算符上的折叠表达式||用于解包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
}

完整的例子在这里。

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

    ([&]{ if(c.GetDataType() == types ) {  std::invoke(f, cast<types>(c), args...); return true; } return false; }() || ...  || []() -> bool{ throw (std::runtime_error("Type not supported")); }());
                                                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
于 2020-08-16T21:44:55.213 回答
1

您不能通过名称传递重载，但您可以传递具有重载的仿函数，operator()因为泛型 lambda 具有。

所以

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); });
于 2020-08-16T21:47:15.740 回答
1

如果您愿意为每个processData类似函数编写一个小型包装类，您可以执行以下操作：

// 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);
于 2020-08-16T20:55:44.157 回答