C++学习笔记-类型双关

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>

struct Entity
{
    int x, y;
};

int main()
{
    Entity e = {5, 8};
    
    // 将Entity*指针转换为int*指针
    int* array = (int*)&e;
    std::cout << "Entity as int array: " << array[0] << ", " << array[1] << std::endl;
    
    // 获取y的值（偏移4字节）
    int y = *(int*)((char*)&e + 4);
    std::cout << "y value through pointer arithmetic: " << y << std::endl;
    
    // 修改Entity的值
    array[0] = 10;
    array[1] = 20;
    std::cout << "Modified Entity: x=" << e.x << ", y=" << e.y << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <iostream>
#include <iomanip>
#include <cstring>

void AnalyzeFloat(float value)
{
    std::cout << "=== Analyzing float: " << value << " ===" << std::endl;
    
    // 方法1：使用指针转换
    uint32_t* intPtr = (uint32_t*)&value;
    uint32_t bits = *intPtr;
    
    std::cout << "Hex representation: 0x" << std::hex << bits << std::dec << std::endl;
    
    // 方法2：使用memcpy（更安全）
    uint32_t safeBits;
    std::memcpy(&safeBits, &value, sizeof(float));
    std::cout << "Safe hex representation: 0x" << std::hex << safeBits << std::dec << std::endl;
    
    // 分析IEEE 754格式
    uint32_t sign = (bits >> 31) & 0x1;
    uint32_t exponent = (bits >> 23) & 0xFF;
    uint32_t mantissa = bits & 0x7FFFFF;
    
    std::cout << "Sign bit: " << sign << std::endl;
    std::cout << "Exponent: " << exponent << " (biased), " << (int(exponent) - 127) << " (unbiased)" << std::endl;
    std::cout << "Mantissa: 0x" << std::hex << mantissa << std::dec << std::endl;
    
    // 重新构造浮点数
    uint32_t reconstructed = (sign << 31) | (exponent << 23) | mantissa;
    float* reconstructedFloat = (float*)&reconstructed;
    std::cout << "Reconstructed value: " << *reconstructedFloat << std::endl;
    std::cout << std::endl;
}

int main()
{
    AnalyzeFloat(3.14159f);
    AnalyzeFloat(-2.5f);
    AnalyzeFloat(0.0f);
    AnalyzeFloat(1.0f);
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#include <iostream>
#include <cstdint>

// 安全的类型双关：使用union
union FloatInt
{
    float f;
    uint32_t i;
    
    FloatInt(float value) : f(value) {}
    FloatInt(uint32_t value) : i(value) {}
};

union DoubleInt64
{
    double d;
    uint64_t i;
    struct {
        uint32_t low;
        uint32_t high;
    } parts;
    
    DoubleInt64(double value) : d(value) {}
};

// 颜色表示的类型双关
union Color
{
    uint32_t value;
    struct {
        uint8_t r, g, b, a;
    } components;
    uint8_t channels[4];
    
    Color(uint32_t val) : value(val) {}
    Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha = 255)
    {
        components.r = red;
        components.g = green;
        components.b = blue;
        components.a = alpha;
    }
};

void UnionTypePunning()
{
    std::cout << "=== Union Type Punning ===" << std::endl;
    
    // 浮点数分析
    FloatInt fi(3.14159f);
    std::cout << "Float: " << fi.f << std::endl;
    std::cout << "As int: 0x" << std::hex << fi.i << std::dec << std::endl;
    
    // 修改浮点数的位
    fi.i |= 0x80000000;  // 设置符号位
    std::cout << "After setting sign bit: " << fi.f << std::endl;
    
    // 双精度浮点数
    DoubleInt64 di(123.456);
    std::cout << "\nDouble: " << di.d << std::endl;
    std::cout << "As int64: 0x" << std::hex << di.i << std::dec << std::endl;
    std::cout << "Low part: 0x" << std::hex << di.parts.low << std::dec << std::endl;
    std::cout << "High part: 0x" << std::hex << di.parts.high << std::dec << std::endl;
    
    // 颜色处理
    Color red(255, 0, 0, 255);
    std::cout << "\nRed color:" << std::endl;
    std::cout << "Value: 0x" << std::hex << red.value << std::dec << std::endl;
    std::cout << "R: " << (int)red.components.r << std::endl;
    std::cout << "G: " << (int)red.components.g << std::endl;
    std::cout << "B: " << (int)red.components.b << std::endl;
    std::cout << "A: " << (int)red.components.a << std::endl;
    
    // 通过数组访问
    std::cout << "Channels: ";
    for (int i = 0; i < 4; ++i)
    {
        std::cout << (int)red.channels[i] << " ";
    }
    std::cout << std::endl;
}

int main()
{
    UnionTypePunning();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <iostream>
#include <cstdint>

union EndianTest
{
    uint32_t value;
    uint8_t bytes[4];
    
    EndianTest(uint32_t val) : value(val) {}
};

bool IsLittleEndian()
{
    EndianTest test(0x12345678);
    return test.bytes[0] == 0x78;
}

uint32_t SwapBytes(uint32_t value)
{
    return ((value & 0xFF000000) >> 24) |
           ((value & 0x00FF0000) >> 8)  |
           ((value & 0x0000FF00) << 8)  |
           ((value & 0x000000FF) << 24);
}

uint16_t SwapBytes(uint16_t value)
{
    return ((value & 0xFF00) >> 8) | ((value & 0x00FF) << 8);
}

void EndianDemo()
{
    std::cout << "=== Endianness Demo ===" << std::endl;
    
    std::cout << "System is " << (IsLittleEndian() ? "Little" : "Big") << " Endian" << std::endl;
    
    uint32_t value = 0x12345678;
    EndianTest test(value);
    
    std::cout << "Value: 0x" << std::hex << value << std::dec << std::endl;
    std::cout << "Bytes in memory: ";
    for (int i = 0; i < 4; ++i)
    {
        std::cout << "0x" << std::hex << (int)test.bytes[i] << " ";
    }
    std::cout << std::dec << std::endl;
    
    uint32_t swapped = SwapBytes(value);
    std::cout << "Byte-swapped: 0x" << std::hex << swapped << std::dec << std::endl;
    
    // 网络字节序转换示例
    uint16_t port = 8080;
    uint16_t networkPort = SwapBytes(port);  // 简化的htons
    std::cout << "Port " << port << " in network byte order: " << networkPort << std::endl;
}

int main()
{
    EndianDemo();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <iostream>
#include <cstdint>

struct PackedStruct
{
    uint8_t a;
    uint16_t b;
    uint32_t c;
} __attribute__((packed));  // GCC/Clang语法

#pragma pack(push, 1)  // MSVC语法
struct MSVCPackedStruct
{
    uint8_t a;
    uint16_t b;
    uint32_t c;
};
#pragma pack(pop)

struct NormalStruct
{
    uint8_t a;
    uint16_t b;
    uint32_t c;
};

template<typename T>
void AnalyzeStruct(const T& obj, const std::string& name)
{
    std::cout << "=== " << name << " ===" << std::endl;
    std::cout << "Size: " << sizeof(T) << " bytes" << std::endl;
    
    const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&obj);
    std::cout << "Memory layout: ";
    for (size_t i = 0; i < sizeof(T); ++i)
    {
        std::cout << "0x" << std::hex << (int)bytes[i] << " ";
    }
    std::cout << std::dec << std::endl;
    
    // 分析字段偏移
    std::cout << "Field offsets:" << std::endl;
    std::cout << "  a: " << offsetof(T, a) << std::endl;
    std::cout << "  b: " << offsetof(T, b) << std::endl;
    std::cout << "  c: " << offsetof(T, c) << std::endl;
    std::cout << std::endl;
}

void StructLayoutDemo()
{
    NormalStruct normal = {0x12, 0x3456, 0x789ABCDE};
    PackedStruct packed = {0x12, 0x3456, 0x789ABCDE};
    MSVCPackedStruct msvcPacked = {0x12, 0x3456, 0x789ABCDE};
    
    AnalyzeStruct(normal, "Normal Struct (with padding)");
    AnalyzeStruct(packed, "Packed Struct (GCC)");
    AnalyzeStruct(msvcPacked, "Packed Struct (MSVC)");
}

int main()
{
    StructLayoutDemo();
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101

#include <iostream>
#include <cmath>
#include <chrono>

// 快速平方根倒数（Quake III算法）
float FastInverseSqrt(float number)
{
    union {
        float f;
        uint32_t i;
    } conv = {number};
    
    conv.i = 0x5f3759df - (conv.i >> 1);
    conv.f *= 1.5f - (number * 0.5f * conv.f * conv.f);
    return conv.f;
}

// 快速绝对值
float FastAbs(float x)
{
    union {
        float f;
        uint32_t i;
    } conv = {x};
    
    conv.i &= 0x7FFFFFFF;  // 清除符号位
    return conv.f;
}

// 快速符号检测
bool IsNegative(float x)
{
    union {
        float f;
        uint32_t i;
    } conv = {x};
    
    return (conv.i & 0x80000000) != 0;
}

void FastMathDemo()
{
    std::cout << "=== Fast Math Demo ===" << std::endl;
    
    float values[] = {4.0f, 9.0f, 16.0f, 25.0f, 100.0f};
    
    std::cout << "Fast inverse square root comparison:" << std::endl;
    for (float val : values)
    {
        float standard = 1.0f / std::sqrt(val);
        float fast = FastInverseSqrt(val);
        float error = std::abs(standard - fast) / standard * 100.0f;
        
        std::cout << "Value: " << val 
                  << ", Standard: " << standard 
                  << ", Fast: " << fast 
                  << ", Error: " << error << "%" << std::endl;
    }
    
    std::cout << "\nFast absolute value:" << std::endl;
    float testVals[] = {-3.14f, 2.71f, -1.0f, 0.0f};
    for (float val : testVals)
    {
        std::cout << "FastAbs(" << val << ") = " << FastAbs(val) << std::endl;
        std::cout << "IsNegative(" << val << ") = " << IsNegative(val) << std::endl;
    }
    
    // 性能测试
    const int iterations = 10000000;
    auto start = std::chrono::high_resolution_clock::now();
    
    volatile float result1 = 0;
    for (int i = 0; i < iterations; ++i)
    {
        result1 += 1.0f / std::sqrt(float(i + 1));
    }
    
    auto mid = std::chrono::high_resolution_clock::now();
    
    volatile float result2 = 0;
    for (int i = 0; i < iterations; ++i)
    {
        result2 += FastInverseSqrt(float(i + 1));
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    
    auto standardTime = std::chrono::duration_cast<std::chrono::milliseconds>(mid - start);
    auto fastTime = std::chrono::duration_cast<std::chrono::milliseconds>(end - mid);
    
    std::cout << "\nPerformance test (" << iterations << " iterations):" << std::endl;
    std::cout << "Standard: " << standardTime.count() << " ms" << std::endl;
    std::cout << "Fast: " << fastTime.count() << " ms" << std::endl;
    std::cout << "Speedup: " << (double)standardTime.count() / fastTime.count() << "x" << std::endl;
}

int main()
{
    FastMathDemo();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <iostream>
#include <cstring>
#include <type_traits>

// 使用memcpy的安全类型转换
template<typename To, typename From>
To SafeTypePun(const From& from)
{
    static_assert(sizeof(To) == sizeof(From), "Types must have the same size");
    static_assert(std::is_trivially_copyable_v<To>, "To type must be trivially copyable");
    static_assert(std::is_trivially_copyable_v<From>, "From type must be trivially copyable");
    
    To to;
    std::memcpy(&to, &from, sizeof(To));
    return to;
}

// 使用std::bit_cast (C++20)
#if __cplusplus >= 202002L
#include <bit>

template<typename To, typename From>
To ModernTypePun(const From& from)
{
    return std::bit_cast<To>(from);
}
#endif

void SafeTypePunningDemo()
{
    std::cout << "=== Safe Type Punning Demo ===" << std::endl;
    
    float pi = 3.14159f;
    
    // 安全的方法
    uint32_t piAsInt = SafeTypePun<uint32_t>(pi);
    std::cout << "Float " << pi << " as uint32_t: 0x" << std::hex << piAsInt << std::dec << std::endl;
    
    // 转换回来
    float backToFloat = SafeTypePun<float>(piAsInt);
    std::cout << "Back to float: " << backToFloat << std::endl;
    
#if __cplusplus >= 202002L
    // C++20方法
    uint32_t modernPun = ModernTypePun<uint32_t>(pi);
    std::cout << "Modern bit_cast: 0x" << std::hex << modernPun << std::dec << std::endl;
#endif
    
    // 危险的方法（仅作对比）
    uint32_t* dangerousPtr = reinterpret_cast<uint32_t*>(&pi);
    std::cout << "Dangerous reinterpret_cast: 0x" << std::hex << *dangerousPtr << std::dec << std::endl;
    
    std::cout << "\nRecommendation: Use memcpy or std::bit_cast for safe type punning" << std::endl;
}

int main()
{
    SafeTypePunningDemo();
    return 0;
}