Why this template specialization for `uint64_t` doesn't match with `unsigned long` on Mac platform?

Question

Why following code snippet compile failed on Mac platform using clang++? The sizeof unsigned long and uint64_t is both 8, so I think they are the same type. So why the compile think the Serializer<unsigned long> is abstract?

Because I have define Serializer<uint64_t>, Serializer<int64_t>, Serializer<uint32_t>, Serializer<int32_t>, Serializer<uint16_t>, Serializer<int16_t>, Serializer<uint8_t>, Serializer<int8_t>, is there any way to resolve this issue and avoid define more type like Serializer<unsigned long>?

Following is the error message, both clang++ and g++ give the similar result:

example.cpp:23:31: error: variable type 'Serializer' is an abstract class

Serializer<unsigned long> s;

                          ^ example.cpp:6:25: note: unimplemented 

pure virtual method 'ToString' in 'Serializer'

virtual std::string ToString(const T* val) = 0;

                    ^ 1 error generated.

#include <iostream>
#include <vector>
#include <algorithm>
template <typename T>
class Serializer {
    virtual std::string ToString(const T* val) = 0;
};

template <>
class Serializer<uint64_t> {
public:

    virtual std::string ToString(const int8_t* val) {
        return "";
    }
};

int main(int argc, const char *argv[])
{
    // both of the size is 8 bytes
    std::cout << " size of unsigned long:" << sizeof(unsigned long) << " sizeof uint64_t:" << sizeof(uint64_t);
    // following compile error happen
    Serializer<unsigned long> s;  //<------- Error happen here
    s.ToString(NULL);

    return 0;
}

Answer 1

As it was discussed ,by using the compile-time-error-method, the type of uint64_t was found out to be unsigned long long instead of unsigned long. Sizes are the same but their names are different and as every one knows compilers are highly sensitive to and strict about names and rightly so!

This can be fixed without any need to change the libraries or to change the user interface!

Just some where in between headers add something like:

template <>
class Serializer<unsigned long> : public Serializer<uint64_t>{};

Or if user can not access the uint64_t type which is more likely the case:

template <>
class Serializer<unsigned long> : public Serializer<unsigned long long>{};

So now it knows that for unsigned long the specialization is (some what) the same as the case of Serializer<uint64_t> which already has been epecialized!

In addition depending on the definition ofSerializer you might also need to add a constructor to it too like:

template <>
class Serializer<unsigned long> : public Serializer<unsigned long long>{
    Serializer(...DATA...):Serializer<unsigned long long>(...DATA...){}
};

If you don't know what is the definition, this might help:

//for values
class Serializer<unsigned long> : public Serializer<unsigned long long>{
    template<typename ... Ts>
    Serializer(Ts ... Vs):Serializer<unsigned long long>(Vs...){}
};

//for objects
class Serializer<unsigned long> : public Serializer<unsigned long long>{
    template<typename ... Ts>
    Serializer(const Ts& ... Os):Serializer<unsigned long long>(Os...){}
};

Good luck!