c++ - 将 ulong 转换为 long

Question

我有一个存储为 ulong 的号码。我希望以 2 的补码方式解释存储在内存中的位。所以我希望第一位是符号位等。如果我想转换为长整数，以便将数字正确解释为 2 的补码，我该怎么做？

我尝试创建不同数据类型的指针，它们都指向同一个缓冲区。然后我将 ulong 存储到缓冲区中。然后我取消引用了一个长指针。然而，这给我带来了不好的结果？

我做到了:

#include <iostream>
using namespace std;

int main() {
    unsigned char converter_buffer[4];//  

    unsigned long       *pulong;
    long                *plong;


    pulong = (unsigned long*)&converter_buffer;
    plong  =  (long*)&converter_buffer;

    unsigned long ulong_num = 65535; // this has a 1 as the first bit

    *pulong = ulong_num;

    std:: cout << "the number as a long is" << *plong << std::endl;
    return 0;
}

出于某种原因，这给了我相同的正数。 类型转换有帮助吗？

Answer 1

实际上使用指针是一个好的开始，但是您必须先将 unsigned long* 转换为 void*，然后才能将结果转换为 long* 并取消引用它:

#include <iostream>
#include <climits>

int main() {
    unsigned long ulongValue = ULONG_MAX;
    long longValue = *((long*)((void*)&ulongValue));

    std::cout << "ulongValue: " << ulongValue << std::endl;
    std::cout << "longValue:  " << longValue << std::endl;

    return 0;
}

上面的代码将产生以下结果:

ulongValue: 18446744073709551615
longValue:  -1

使用模板，您可以使其在代码中更具可读性:

#include <iostream>
#include <climits>

template<typename T, typename U>
T unsafe_cast(const U& from) {
    return *((T*)((void*)&from));
}

int main() {
    unsigned long ulongValue = ULONG_MAX;
    long longValue = unsafe_cast<long>(ulongValue);

    std::cout << "ulongValue: " << ulongValue << std::endl;
    std::cout << "longValue:  " << longValue << std::endl;

    return 0;
}

请记住，此解决方案绝对不安全，因为您可以将任何内容转换为 void*。这种做法在 C 中很常见，但我不建议在 C++ 中使用它。考虑以下情况:

#include <iostream>

template<typename T, typename U>
T unsafe_cast(const U& from) {
    return *((T*)((void*)&from));
}

int main() {
    std::cout << std::hex << std::showbase;

    float fValue = 3.14;
    int iValue = unsafe_cast<int>(fValue); // OK, they have same size.

    std::cout << "Hexadecimal representation of " << fValue
              << " is: " << iValue << std::endl;
    std::cout << "Converting back to float results: "
              << unsafe_cast<float>(iValue) << std::endl;

    double dValue = 3.1415926535;
    int lossyValue = unsafe_cast<int>(dValue); // Bad, they have different size.

    std::cout << "Lossy hexadecimal representation of " << dValue
              << " is: " << lossyValue << std::endl;
    std::cout << "Converting back to double results: "
              << unsafe_cast<double>(lossyValue) << std::endl;

    return 0;
}

上面的代码为我带来了以下结果:

Hexadecimal representation of 3.14 is: 0x4048f5c3
Converting back to float results: 3.14
Lossy hexadecimal representation of 3.14159 is: 0x54411744
Converting back to double results: 6.98387e-315

最后一行你可以得到任何东西，因为转换将从内存中读取垃圾。

编辑

作为lorro评论如下，使用 memcpy() 更安全并且可以防止溢出。所以，这是另一个更安全的类型转换版本:

template<typename T, typename U>
T safer_cast(const U& from) {
    T to;
    memcpy(&to, &from, (sizeof(T) > sizeof(U) ? sizeof(U) : sizeof(T)));
    return to;
}