给定 3^个第三方函数...

void obj_from_int32( int32_bytes_t& i );
void obj_from_int64( int64_bytes_t& i );
void obj_from_uint32( uint32_bytes_t& i );
void obj_from_uint64( uint64_bytes_t& i );

您可以为内置类型调用"正确"的此类函数，如下所示：

template< int nBytes, bool isSigned >
struct ThirdParty;
template<>
struct ThirdParty< 4, true >
{
    template< class IntegralT >
    static void func( IntegralT& v )
    { obj_from_int32( v ) }    // Add whatever conversion is required.
};
// Etc., specializations of ThirdParty for unsigned and for 8 bytes.
template< class IntegralT >
void myFunc( IntegralT& v )
{ ThirdParty< sizeof( v ), std::is_signed< IntegralT >::value >::func( v ); }

不是重载，而是模式匹配呢？ 使用boost::enable_if和帮助程序模板来选择您要查找的操作类型？

像这样：

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <iostream>
template <typename T, typename Dummy=void> struct helper;
// Handle signed integers of size 1 (8 bits)
template <typename T> struct helper<T, 
    typename boost::enable_if_c<
        boost::is_integral<T>::value && 
        (sizeof(T)==1) &&
        (static_cast<T>(-1) < static_cast<T>(0)) >::type>
{
    static void do_stuff(T const& ) {std::cout<<"signed, size 1"<<std::endl;}
};
// Handle unsigned integers of size 1 (8 bits)
template <typename T> struct helper<T, 
    typename boost::enable_if_c<
        boost::is_integral<T>::value &&
        (sizeof(T)==1) &&
        (static_cast<T>(-1) > static_cast<T>(0)) >::type>
{
    static void do_stuff(T const& ) {std::cout<<"unsigned, size 1"<<std::endl;}
};
// Handle signed integers of size 2 (16 bits)
template <typename T> struct helper<T, 
    typename boost::enable_if_c<
        boost::is_integral<T>::value && 
        (sizeof(T)==2) &&
        (static_cast<T>(-1) < static_cast<T>(0)) >::type>
{
    static void do_stuff(T const& ) {std::cout<<"signed, size 2"<<std::endl;}
};
// And so on and so forth....
// Use a function for type erasure:
template <typename T> void do_stuff(T const& value)
{
    helper<T>::do_stuff(value);
}
int main()
{
    do_stuff(static_cast<unsigned char>(0)); // "unsigned, size 1"
    do_stuff(static_cast<signed short>(0));  // "signed, size 2"
}

更完整的列表(并证明它至少适用于 GCC(在 http://ideone.com/pIhdq。

编辑：或者更简单，但覆盖范围可能较小：(使用标准积分类型(

template <typename T> struct helper2;
template <> struct helper2<uint8_t> {static void do_stuff2(uint8_t ) {...}};
template <> struct helper2<int8_t> {static void do_stuff2(int8_t ) {...}};
template <> struct helper2<uint16_t> {static void do_stuff2(uint16_t ) {...}};
template <> struct helper2<int16_t> {static void do_stuff2(int16_t ) {...}};
// etc.
template <typename T> void do_stuff2(T value) {helper2<T>::do_stuff2(value);}

正如我们在链接问题中发现的那样，长是这里歧义的原因。该行

MyClass(long z): _val(objFromInt(z)) {}

应更改为以下内容：

MyClass(long z): _val(sizeof(long) == 4 ? static_cast<int32_t>(z) : static_cast<int64_t>(z)))) {}

请注意，您可能会在 64 位 gcc 上遇到类似的长长问题。

正如其他答案中所指出的，这可以在运行时使用if(sizeof(int)==sizeof(int32_t))样式分支轻松解决。要在编译时执行此操作，可以使用boost::enable_if。

template <class InputT>
typename boost::enable_if_c<sizeof(InputT)==sizeof(int32_t) && boost::is_signed<InputT>::value,
 int32_t>::type ConvertIntegral(InputT z) { return static_cast<int32_t>(z); }
template <class InputT>
typename boost::enable_if_c<sizeof(InputT)==sizeof(int64_t) && boost::is_signed<InputT>::value, 
int64_t>::type ConvertIntegral(InputT z) { return static_cast<int64_t>(z); }
template <class InputT>
typename boost::enable_if_c<sizeof(InputT)==sizeof(uint32_t) && boost::is_unsigned<InputT>::value, 
uint32_t>::type ConvertIntegral(InputT z) { return static_cast<uint32_t>(z); }
template <class InputT>
typename boost::enable_if_c<sizeof(InputT)==sizeof(uint64_t) && boost::is_unsigned<InputT>::value, 
uint64_t>::type ConvertIntegral(InputT z) { return static_cast<uint64_t>(z); }

任何需要将整型类型转换为int32_t、int64_t、uint32_t或uint64_t只需调用如下：

ConvertIntegral(long(5));  // Will return a type compatible with int32_t or int64_t

ConvertIntegral功能可以与int32_t和int64_t过载组相结合，以获得完整的解决方案。或者，所示技术可以内置到过载集中。

此外，可以通过禁用非整型类型来进一步增强上述内容。有关使用这些函数的完整示例，请参阅函数的不明确重载，例如"msg(long("，候选函数"msg(int32_t("和"msg(int64_t(">

义很容易源于有符号和无符号类型的重载。例如，给定

void foo(unsigned int);
void foo(long);

那么foo(0)是模棱两可的，因为从int到unsigned int和long的转化(或可能是促销(排名相同。

选择一个有符号，或者为每个签名编写两个重载集(如果您使用的是使用无符号类型的构造函数重载((并且您关心这一点(。