c++ - 具有 32 位/64 位整数重载的模板函数

Question

实际函数 bar 应该从文件中读取，其中数据以正好 4 个字节或 8 个字节写入(unsigned int - DWORD 或 DWORD64)

void bar(DWORD64&);
void bar(DWORD&);

template<typename IntType>
void foo(IntType& out)
{
    bar(out);
}

int main()
{
    int a;
    foo(a); // Caller doesn't care
}

因为调用者可以传递任何整数类型(int、LONG、DWORD、LONGLONG 或任何类型) - 我想要一种技术，以便 foo 可以调用 32 位 bar 或 64 位 bar。

简而言之，它就像:

template<typename IntType>
void foo(IntType& out)
{
       if(sizeof(out)==sizeof(DWORD))  // 32-bit
       {
             DWORD data;
             bar(data); // call DWORD version
             out = (IntType)data; // Ignore truncation etc.
       }
       else
       { 
             DWORD64 data;
             bar(data); // call DWORD64 version
             out = (IntType)data; // Ignore truncation etc.
       }
 }

显然，我希望在编译时解决“if”部分。 std::enable_if 之类的？

Answer 1

解决方案 1:SFINAE 和 std::enable_if:

template<typename IntType, typename std::enable_if<sizeof(IntType) == 4>::type* = nullptr>
void foo(IntType& out)
{
    DWORD arg = out;
    bar(arg);
    out = arg;
}

template<typename IntType, typename std::enable_if<sizeof(IntType) == 8>::type* = nullptr>
void foo(IntType& out)
{
    DWORD64 arg = out;
    bar(arg);
    out = arg;
}

解决方案 2:委托(delegate)类和部分特化:

template<typename IntType>
void foo(IntType& out)
{
    foo_helper<IntType>::call(out);
}

template <class IntType, std::size_t Size = sizeof(IntType)>
struct foo_helper;

template <class IntType>
struct foo_helper<IntType, 4>
{
  static void call(IntType &out)
  {
    DWORD arg = out;
    bar(arg);
    out = arg;
  }
};

template <class IntType>
struct foo_helper<IntType, 8>
{
  static void call(IntType &out)
  {
    DWORD64 arg = out;
    bar(arg);
    out = arg;
  }
};

这两种解决方案都可以通过添加 static_cast 来调味，特别是围绕 arg 的赋值。