Add bit_cast, and use it for _beginthreadex calls

[N-Dekker]

bit_cast helps to avoid undefined behavior when doing a bitwise cast.

[N-Dekker]

@dzenanz I'm sorry, my claim that the (HANDLE) cast would cause undefined behavior was too strong. (Meaning I was wrong 😸.) As was just explained to me at the #include <C++> discussion channel, referring to http://eel.is/c++draft/expr.reinterpret.cast#4

A pointer can be explicitly converted to any integral type large enough to hold all values of its type. The mapping function is implementation-defined.

In this particular case, the (HANDLE) cast would behave just like a reinterpret_cast<HANDLE>.

I still think that in this particular case, bit_cast<HANDLE> is preferable to reinterpret_cast<HANDLE>, because the behavior of C++20 bit_cast is defined by the C++ Standard, rather than just "implementation-defined".

In other cases, bit_cast does actually prevent undefined behavior, for example (https://godbolt.org/z/xearxvxM6):

float f = 0.1f;
int i1 = reinterpret_cast<int & >(f); // Undefined behavior!
int i2 = bit_cast<int>(f); // OK

[N-Dekker]

For the record, this pull request + discussion appears related to issue isocpp/CppCoreGuidelines#1517 "Favor bit_cast over reinterpret_cast".

[N-Dekker]

@Leengit Could you possibly have a look at this issue as well? It seems that I was too eager to start using bit_cast, rather than reinterpret_cast! You may find the discussion at issue isocpp/CppCoreGuidelines#1517 "Favor bit_cast over reinterpret_cast" interesting. 😄

Jason Turner has two short video's on this topic, however, they don't seem to apply specifically to the (HANDLE) cast that I was addressing with this pull request:

• C++ Weekly - Ep 185 - Stop Using reinterpret_cast!
• C++ Weekly - Ep 265 - C++20's std::bit_cast

So I'm now considering to replace the itk::bit_cast<HANDLE> calls from this pull request by reinterpret_cast's. What do you think?

[Leengit]

This is a new one for me and I haven't followed all your links, so I may end up wishing to eat my words in the next few hours or minutes but ... I am thinking that I would continue to use reinterpret_cast for objects of different sizes and for arrays and pointers. I would use bit_cast only if the from and to objects are neither pointers nor arrays and are of the same size.

  double * pDouble = nullptr;
  // this next line is good enough because it is to char* (assuming sizeof(char)==1) or void*
  char * pChar = reinterpret_cast<char *>(pDouble);

  float        f = 1.0f;
  unsigned int i1 = std::bit_cast<unsigned int>(f);        // yes
  unsigned int i2 = *reinterpret_cast<unsigned int *>(&f); // now deprecated

And if they are not trivially copyable then I don't know.