我有这样的数据结构

enum DataType_t{INT,FLOAT};
struct Data
{
   DataType_T type;
   void* min;
   void* max;
};

变量min 和max 取决于type 的值。我想知道是否有办法创建 std::map 之类的

std::map<DataType_t, SomeFcnPtr> myMap;
myMap[INT] = ?? // Here should be a pointer to a function like int(*FcnPtr)(Data d, bool min);
myMap[FLOAT] = ?? // Here should be a pointer to a function like float(*FcnPtr)(Data d, bool min);

有没有办法创建这样一个具有不同返回数据类型的函数指针的映射？

最后我想用它来归一化值

float normalizedValue = (readValue - mayMap[INT](intData, true)) / (mayMap[INT](intData, false) - mayMap[INT](intData, true))

我读了this post看起来非常相似但不理解所提出的想法，也许你可以举个例子。

编辑

我将对我正在尝试的内容添加更多解释。 struct Data 有一个字段 DataType_t type。根据 type 的值，我需要正确地转换 min 和 max 字段以将其正确表示为 int 或 float 。一种可能的方法是

int getMinOrMaxForINT(Data aData, bool min)
{
   if(min) return *((int*)aData.min));
   return *((int*)aData.max));
}

和类似的

float getMinOrMaxForFLOAT(Data aData, bool min)
{
   if(min) return *((float*)aData.min));
   return *((float*)aData.max));
}

终于在一些处理 Data 变量的函数中我可以做到了

void someFunction(int value, Data aData)
{
   float normalizedValue = 0;
   if(aData.type == DataType_t::INT)
   {
      normalizedValue = (value - getMinOrMaxForINT(aData, true)) / (getMinOrMaxForINT(aData, false) - getMinOrMaxForINT(aData, true));
   }
   else if(aData.type == DataType_t::FLOAT)
   {
      normalizedValue = (value - getMinOrMaxForFLOAT(aData, true)) / (getMinOrMaxForFLOAT(aData, false) - getMinOrMaxForFLOAT(aData, true));
   }
}

如您所见，getMinOrMaxForXXXX 的代码除了返回类型和转换类型外完全相同。我想到了使用像

template <typename T>
T getMinOrMax(Data aData, bool min)
{
       if(min) return *((T*)aData.min));
       return *((T*)aData.max));
}

但问题是如何让 map 获得指向某个特化的指针，例如

myMap[DataType_t::INT] = //PointerTo getMinOrMax<int>
myMap[DataType_t::FLOAT] = //PointerTo getMinOrMax<float>

这可以帮助我简化流程函数中的函数代码

void someFunction(int value, Data aData)
{
   float normalizedValue = (value - myMap[aData.type](aData, true)) / (myMap[aData.type](aData, false) - myMap[aData.type](aData, true));
}

最佳答案

使用 std::tuple< std::pair< DataType, std::function< void() > > > myMap;

然后在此处使用此技术实现按类型获取的工厂示例: https://github.com/alekstheod/tnnlib/blob/master/src/Utilities/Utilities/Design/Factory.h

按类型获取看这里: https://github.com/alekstheod/tnnlib/blob/master/src/Utilities/Utilities/MPL/Tuple.h

从这里开始:

    int retInt(){
  return 1;
}

float retFloat(){
  return 1.f;
}

char retChar(){
  return 'a';
}

int main(int, char *[])
{

  std::tuple< std::pair< int, std::function< int () > >,
             std::pair< float, std::function< float() > >,
             std::pair< char, std::function< char () > > > map;

  std::get<0>(map).second = retInt;
  int result = std::get<0>(map).second();
  return 0;
}

这是一个简单的示例，当我从元组中取出第一个元素并执行该函数时。现在我们需要使用类型来查找元素，而不是获取第一个元素。一些元编程:

namespace detail{

template <class T, std::size_t N, class... Args>
struct get
{
  static const auto value = N;
};

template <class T, std::size_t N, class... Args>
struct get<T, N, T, Args...>
{
  static const auto value = N;
};

template <class T, std::size_t N, class U, class... Args>
struct get<T, N, U, Args...>
{
  static const auto value = get<T, N + 1, Args...>::value;
};

}

template <class T, class... Args>
std::pair< T, std::function< T() > >& get(std::tuple<Args...>& t)
{
    using Entry = std::pair<T, std::function<T()> >;
    return std::get<detail::get<Entry, 0, Args...>::value>(t);
}

然后调用它看起来像:

int main(int, char *[])
{

  std::tuple< std::pair< int, std::function< int () > >,
             std::pair< float, std::function< float() > >,
             std::pair< char, std::function< char () > > > map;

  get< int >(map).second = retInt;
  int result = get<int>(map).second();

  get< float >(map).second = retFloat;
  float result2 = get< float >(map).second();

  return 0;
}

您可以替换函数的返回类型或函数本身。或者您可以保持原样并进行绑定(bind)，以防需要更多参数。

关于c++ - 如何将数据类型的 std::map 制作为函数指针，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30405177/