g++ (11) -Wuseless-cast gives lots of warnings

[fhuberts]

What is the issue you have?

When I compile the 'single include' file on g++ v11 on my Fedora 34 machine with the '-Wuseless-cast' flags enabled then I get lots of warnings.

Please describe the steps to reproduce the issue.

1. enable the -Wuseless-cast compiler flag and compile

Can you provide a small but working code example?

What is the expected behavior?

And what is the actual behavior instead?

Which compiler and operating system are you using?

• Compiler: gnu g++ v11
• Operating system: Fedora 34 x64

g++ (GCC) 11.1.1 20210531 (Red Hat 11.1.1-3)
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Which version of the library did you use?

• latest release version 3.9.1
• other release - please state the version: commit a563338
• the develop branch

If you experience a compilation error: can you compile and run the unit tests?

• yes
• no - please copy/paste the error message below

[nlohmann]

Can you provide the warnings?

[fhuberts]

So it turns out 'lots' is 2. I just saw lots because we include it in lots of places. oops.

xxx/json.hpp: In member function ‘bool nlohmann::detail::binary_reader<BasicJsonType, InputAdapterType, SAX>::parse_cbor_internal(bool, nlohmann::detail::cbor_tag_handler_t)’:
xxx/json.hpp:8856:80: warning: useless cast to type ‘std::size_t’ {aka ‘long unsigned int’} [-Wuseless-cast]
 8856 |                 return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
      |                                                                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
xxx/json.hpp:8910:81: warning: useless cast to type ‘std::size_t’ {aka ‘long unsigned int’} [-Wuseless-cast]
 8910 |                 return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
      |                                                                                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[nlohmann]

These are hard to fix, because not all architectures have the same definitions for size_t.

[nlohmann]

I double checked. In both cases, there is a cast from std::uint64_t to std::size_t:

std::uint64_t len{};
return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);

I case these types are the same, your reported warning makes sense. However, the types do not necessarily need to be the same.

Does anyone has an idea how to silence this warning?

[t-b]

I guess one could use something like the following

#include <type_traits>

template<typename T, typename U, std::enable_if_t<!std::is_same<T, U>::value, int> = 0>
T conditional_static_cast(U value)
{
return static_cast<T>(value);
}

template<typename T, typename U, std::enable_if_t<std::is_same<T, U>::value, int> = 0>
T conditional_static_cast(U value)
{
return value;
}

void func()
{
    int a = conditional_static_cast<int>(0);
    int b = static_cast<int>(0);

}

The first line in func gives no warning the second does.

[fhuberts]

I think I've dealt with this before, need to look it up.
Solution was something with ifdef's and type sizes.

However, the template solution above does seem elegant.

[nlohmann]

Thanks @t-b - I was thinking of preprocessor magic before, but this is much cleaner. I'll give it a try, see #2902.