Why Does `int64_t` Behave Differently in 64-bit GCC Compiles?

Long Long Int vs. Long Int vs. Int64_t in C

C type traits can exhibit quirky behavior, particularly with signed 64-bit integer types. Here's an exploration of why:

In both 32-bit and 64-bit compiles (GCC and MSVC), the following program behaves as expected:

<code class="cpp">#include &lt;iostream&gt;
#include &lt;cstdint&gt;

template &lt;typename T&gt;
bool is_int64() { return false; }

template &lt;&gt;
bool is_int64&lt;int64_t&gt;() { return true; }

int main()
{
    std::cout &lt;&lt; &quot;int:\t&quot; &lt;&lt; is_int64&lt;int&gt;() &lt;&lt; std::endl;
    std::cout &lt;&lt; "int64_t:\t" &lt;&lt; is_int64&lt;int64_t&gt;() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;long int:\t&quot; &lt;&lt; is_int64&lt;long int&gt;() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;long long int:\t&quot; &lt;&lt; is_int64&lt;long long int&gt;() &lt;&lt; std::endl;

    return 0;
}</code>

The output correctly indicates that int64_t, long int, and long long int are all equivalent 64-bit integer types.

However, a 64-bit GCC compile produces a different result:

int:           0
int64_t:       1
long int:      1
long long int: 0

This surprising behavior stems from the C standard library definition of int64_t:

<code class="cpp"># if __WORDSIZE == 64
typedef long int  int64_t;
# else
__extension__
typedef long long int  int64_t;
# endif</code>

In a 64-bit compile, int64_t is defined as long int, not long long int. This means that the is_int64() template specialization that checks for int64_t will match long int instead of long long int.

Solution using Partial Template Specialization:

To address this issue, you can use partial template specialization to explicitly define is_int64() for long long int:

<code class="cpp">#if defined(__GNUC__) &amp;&amp; (__WORDSIZE == 64)
template &lt;&gt;
bool is_int64&lt;long long int&gt;() { return true; }
#endif</code>

However, this solution is dependent on the compiler and can be tedious to implement for every affected type.

Alternative Solution using Boost:

Boost provides a more elegant solution with the boost::is_same variadic template:

<code class="cpp">#include &lt;boost/type_traits/is_same.hpp&gt;

template &lt;typename T&gt;
bool is_int64_boost() { return boost::is_same&lt;T, int64_t&gt;::value; }

int main()
{
    std::cout &lt;&lt; &quot;int:\t&quot; &lt;&lt; is_int64_boost&lt;int&gt;() &lt;&lt; std::endl;
    std::cout &lt;&lt; "int64_t:\t" &lt;&lt; is_int64_boost&lt;int64_t&gt;() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;long int:\t&quot; &lt;&lt; is_int64_boost&lt;long int&gt;() &lt;&lt; std::endl;
    std::cout &lt;&lt; "long long int:\t" &lt;&lt; is_int64_boost&lt;long long int&gt;() &lt;&lt; std::endl;

    return 0;
}</code>

This approach will correctly identify all equivalent 64-bit integer types, regardless of their exact representation in the standard library.

The above is the detailed content of Why Does `int64_t` Behave Differently in 64-bit GCC Compiles?. For more information, please follow other related articles on the PHP Chinese website!