格雷格一针见血：int32_t和int64_t是typedef，可能是也可能不是long。如果两者都不是long的typedef，重载解析可能失败。long->int32_t和long->int64_t均具有秩=提升（表12，13.3.3.1.2）

代码是否可以编译是由实现定义的。没有类型int32_t或int64_t;这些只是现有整型的typedef。如果类型恰好是一个已经重载的类型（int，long或long long），这几乎是肯定的，那么你有同一个函数的多个定义。如果它们在同一个翻译单元中，则是编译时错误，需要进行诊断。如果它们在不同的翻译单元中，这是未定义的行为，但我想大多数实现也会生成错误。
在您的情况下，最好的解决方案可能是将msg作为模板，并将类型的名称作为参数传递。

| 免责声明|
| --|
| 这个解决方案最初是由作者在他们的问题中发布的。|
解决方案是提供一个函数，成功地将int，long和long longMap到适当的int32_t或int64_t。这可以在运行时通过if (sizeof(int)==sizeof(int32_t))类型语句简单地完成，但编译时解决方案更可取。通过使用boost::enable_if可以获得编译时解决方案。
以下代码适用于MSVC 10和gcc 4.6.3。可以通过禁用非整数类型来进一步增强解决方案，但这超出了此问题的范围。

#include <iostream>
#include <stdint.h>

#include <boost/integer.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_unsigned.hpp>

using namespace std;

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); }

void msg(int v) { cout << "int: " << sizeof(int) << ' ' << v << '\n'; }
void msg(long v) { cout << "long: " << sizeof(long) << ' ' << v << '\n'; }
void msg(long long v) { cout << "long long: " << sizeof(long long) << ' ' << v << '\n'; }

void msg2(int32_t v) { cout << "int32_t: " << sizeof(int32_t) << ' ' << v << '\n'; }
void msg2(int64_t v) { cout << "int64_t: " << sizeof(int64_t) << ' ' << v << '\n'; }
void msg2(uint32_t v) { cout << "uint32_t: " << sizeof(uint32_t) << ' ' << v << '\n'; }
void msg2(uint64_t v) { cout << "uint64_t: " << sizeof(uint64_t) << ' ' << v << '\n'; }

int main()
{
 
    int myInt = -5;
    long myLong = -6L;
    long long myLongLong = -7LL;

    unsigned int myUInt = 5;
    unsigned int myULong = 6L;
    unsigned long long myULongLong = 7LL;

    msg(myInt);
    msg(myLong);
    msg(myLongLong);

    msg2(ConvertIntegral(myInt));
    msg2(ConvertIntegral(myLong));
    msg2(ConvertIntegral(myLongLong));
  
    msg2(ConvertIntegral(myUInt));
    msg2(ConvertIntegral(myULong));
    msg2(ConvertIntegral(myULongLong));

   return 0;
}

正如在其他答案中提到的，模板参数推导在这种情况下可以提供帮助，但它不足以消除<cstdint>中定义的所有可能的typedef之间的歧义。

#include <iostream>
#include <cstdint>
#include <concepts>
#include <string_view>
#include <format>

template< std::integral I >
constexpr auto name_of(I v)
    -> std::string_view
{
    if constexpr ( std::same_as<I, char> )
        return "char";
    else if constexpr ( std::unsigned_integral<I> )
        if constexpr ( sizeof v < 2 )
            return "uint8_t";
        else if constexpr ( sizeof v < 4 )
            return "uint16_t";
        else if constexpr ( sizeof v < 8 )
            return "uint32_t";
        else
            return "uint64_t";  
    else
        if constexpr ( sizeof v < 2 )
            return "int8_t";
        else if constexpr ( sizeof v < 4 )
            return "int16_t";
        else if constexpr ( sizeof v < 8 )
            return "int32_t";
        else
            return "int64_t";  
}

template< std::integral I >
void msg2(I v)
{
    std::cout << std::format("{:8}{:3}  ", name_of(v), sizeof v);
    
    if constexpr ( std::same_as<I, char> )
        std::cout << '\'' << v << "\'\n";
    else if constexpr ( sizeof(I) == 1 )
        std::cout << static_cast<int>(v) << '\n';
    else
        std::cout << v << '\n';
}

int main()
{
    msg2(-5);
    msg2(-6LL);
    msg2(-7LL);
    msg2(5U);
    msg2(6UL);
    msg2(7ULL);
  
    msg2(int8_t{42});
    msg2((signed char)'a');   // <-- Indistinguishable from int8_t
    msg2('b');
    msg2((unsigned char)'c'); // <-- Same as uint8_t
}

Demo