0

I am trying to compile ustl C++ library with MinGW GCC compiler on Windows 10.

The 41st line in the C++ header below was able to solve thanks to this answer, but there is a problem at line 43. How should I solve it?

https://github.com/msharov/ustl/blob/master/fstream.h#L41

    // int          ioctl (const char* rname, int request, long argument = 0);   // orig
    int         ioctl (const char* rname, int request, long argument = 0u);
    inline int      ioctl (const char* rname, int request, int argument)    { return fstream::ioctl (rname, request, long(argument)); }
    inline int      ioctl (const char* rname, int request, void* argument)  { return fstream::ioctl (rname, request, intptr_t(argument)); }

MinGW GCC compiler (10.3.0 (Rev5, Built by MSYS2 project)) error message:

fstream.h:43:132: error: call of overloaded 'ioctl(const char*&, int&, uintptr_t)' is ambiguous
    43 |     inline int  ioctl (const char* rname, int request, void* argument) { return fstream::ioctl (rname, request, uintptr_t(argument)); }

-- Edit: Thanks for the hint. With another answer, below code works for me:

https://github.com/msharov/ustl/blob/master/fstream.h#L43

 // ... intptr_t(argument));  // orig
 *((long*)(argument)));
sailfish009
  • 2,561
  • 1
  • 24
  • 31
  • It's hard to say without knowing the definition (e.g. what is `uintptr_t` in ustl?) - and I'm not inclined to trawl through all source of the ustl library to find out. I suspect the ustl code assumes some types are distinct, but they are not with mingw (e.g. `int` and `long` can be different types with some compilers, but not on others - which can cause ambiguity if a function has both `int` and `long` (or `int *` and `long *`) overloads). This is a common portability gotcha for library developers. Anyway, why not use the C++ standard library shipped by your compiler? It supersedes the STL. – Peter Sep 04 '21 at 02:40
  • @Peter because i can! :P curiosity, want to see more smaller code to test myself. – sailfish009 Sep 04 '21 at 05:31

1 Answers1

3

You can find in the last few words that

fstream.h:43:132: error: call of overloaded 'ioctl(const char*&, int&, uintptr_t)' is ambiguous 43 | inline int ioctl (const char* rname, int request, void* argument) { return fstream::ioctl (rname, request, uintptr_t(argument)); }

intptr_t is actually a uintptr_t in your environment. And as for uintptr_t, you can find in cppreference that it's an unsigned integer.

According to ranking of implicit conversion sequence in overload resolution, unsigned sth => long and unsigned sth => int are equivalent(both conversion). So no winner, all loser, which leads to compilation error.

If you just want to avoid compilation error, convert intptr_t to long helps. But I think the best way is to use proper type that stands for its meaning. For example, if it's for an address, then just use uintptr_t in the beginning, and make it a convention.

SHP
  • 305
  • 1
  • 7