使用C++11，您可以执行以下操作：

#include <iostream>
#include <iomanip>
#include <type_traits>

// First implementation of printer
class Impl1 {
public:
    static void print(uint64_t value, int base) {
        std::cout << "64-bit print: " << std::setbase(base) << value << "\n";
    }
};

// Second implementation of printer
class Impl2 {
public:
    static void print(uint32_t value, int base) {
        std::cout << "32-bit print: " << std::setbase(base) << value << "\n";
    }
};

// Template to automatically select proper version
template<typename Impl, typename = void>
class Print;

template<typename Impl>
class Print<Impl, typename std::enable_if<std::is_same<decltype(Impl::print), void(uint64_t, int)>::value>::type>
{
public:
    static void print(uint64_t value, int base)
    {
        Impl::print(value, base);
    }
};

template<typename Impl>
class Print<Impl, typename std::enable_if<std::is_same<decltype(Impl::print), void(uint32_t, int)>::value>::type>
{
public:
    static void print(uint64_t value, int base)
    {
        Impl::print(static_cast<uint32_t>(value >> 32), base);
        Impl::print(static_cast<uint32_t>(value), base);
    }
};

int main()
{
    Print<Impl1>::print(0x100000001, 16);
    Print<Impl2>::print(0x100000001, 16);
}

第二个版本，具有函式多载和标准型别：

#include <iomanip>
#include <iostream>
#include <type_traits>

// Set to 1 to see effect of using 64 bit version
#define HAS_64 0

class Print {
    public:
    size_t print(unsigned int value, int base) {
        return base + 1;  // dummy
    };
    size_t print(long value, int base) {
        return base + 2;  // dummy
    };
    size_t print(unsigned long value, int base) {
        return base + 3;  // dummy
    };
#if HAS_64    
    size_t print(unsigned long long value, int base) {
        return base + 4;  // dummy
    };
#endif
};
Print MySerial;

// If you have C++17 you can just use std::void_t, or use this for all versions
#if __cpp_lib_void_t >= 201411L
template<typename T>
using void_t = std::void_t<T>;
#else
template<typename... Ts> struct make_void { typedef void type; };
template<typename... Ts> using void_t = typename make_void<Ts...>::type;
#endif

// Detecting if we have 'print(unsigned long long value, int base)' overload
template<typename T, typename = void>
struct has_ull_print : std::false_type { };
template<typename T>
struct has_ull_print<T, void_t<decltype(std::declval<T>().print(0ull, 0))>> : std::true_type { };

// Can be either class or namesapce
namespace PrintXYZ {
    template <typename Impl, typename std::enable_if<!has_ull_print<Impl>::value, bool>::type = true>
    size_t print(Impl &p, unsigned long long value, int base) {
        p.print(static_cast<uint32_t>(value >> 32), base);
        p.print(static_cast<uint32_t>(value), base);
        return 0; // Not sure about return value here.
    }

    template <typename Impl, typename std::enable_if<has_ull_print<Impl>::value, bool>::type = true>
    size_t print(Impl &p, unsigned long long value, int base) {
        return p.print(value, base);
    }
};

int main() {
    PrintXYZ::print(MySerial, 0x100000001, 16);
}

问题是文档太少。我找到了this，但它没有提供Serial::print重载的定义。
我猜想它看起来是这样的：

class Serial
{
public:
    ...
    void print(uint8_t x, int base);
    void print(uint16_t x, int base);
    void print(uint32_t x, int base);
    void print(uint64_t x, int base);
};

所以当你在unsigned long long上使用这个时，你期望它与uint64_t匹配重载，但是在某些平台上uint64_t不是unsigned long long，而是unsigned long。这种不匹配导致重载解析无法决定使用哪个回退并报告错误：call of overloaded 'print(decodedData, int)' is ambiguous .
因此，与其用“避免调用函数”来使你的生活复杂化，不如显式地使用类型uint64_t来修复你的代码。注意，这个类型定义解释了你的意图，所以你应该明确地使用它。

uint64_t decodedData;
Print MySerial;
MySerial.print(decodedData, 16);

如果我错了，请提供更好的链接到这个API文档。也包括完整的错误日志时，建立失败，所以我们可以看到什么重载是可用的。