Warum verhält sich „long int“ in C manchmal wie „int64_t“?

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

Bei der Verwendung von C-Typ-Merkmalen kann es zu eigenartigem Verhalten kommen. Betrachten Sie das folgende Programm:

<code class="c++">#include <iostream>
#include <cstdint>

template <typename T>
bool is_int64() { return false; }

template <>
bool is_int64<int64_t>() { return true; }

int main()
{
    std::cout << "int:\t" << is_int64<int>() << std::endl;
    std::cout << "int64_t:\t" << is_int64<int64_t>() << std::endl;
    std::cout << "long int:\t" << is_int64<long int>() << std::endl;
    std::cout << "long long int:\t" << is_int64<long long int>() << std::endl;

    return 0;
}</code>

Bei 32-Bit-Kompilierungen ist die Ausgabe wie erwartet:

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

Bei 64-Bit-GCC-Kompilierungen ist die Ausgabe jedoch anders:

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

Dies liegt an einem Unterschied in der Definition von int64_t im 64-Bit-Modus:

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

Im 64-Bit-Modus ist int64_t als long int und nicht als long long definiert int.

Um dies zu beheben, könnte man die is_int64-Vorlage für long long int spezialisieren:

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

Dies ist jedoch eine hackige Lösung. Gibt es eine Möglichkeit, dem Compiler Typäquivalenz anzugeben?

Leider ist dies in C/C nicht möglich. Der Compiler definiert die grundlegende Äquivalenz von Datentypen und Typedefs funktionieren nur in eine Richtung.

Eine alternative Problemumgehung besteht darin, Typmerkmale zu verwenden, um die Eigenschaften von Typen zu überprüfen, anstatt sich auf ihre genauen Namen zu verlassen:

<code class="c++">template <typename T>
struct some_type_trait : boost::false_type { };

template <>
struct some_type_trait<int64_t> : boost::true_type { };

// Usage
if (some_type_trait<long int>::value) {
    // ...
}</code>

Dieser Ansatz ermöglicht die Überprüfung von Typeigenschaften, ohne Typen explizit zu vergleichen.

Das obige ist der detaillierte Inhalt vonWarum verhält sich „long int“ in C manchmal wie „int64_t“?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!