将ulong转换为long

Question

我有一个数字存储为ulong。 我希望存储在内存中的位以2的补码方式解释。 所以我希望第一位是符号位等。如果我想转换为long，那么数字被正确解释为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;
}

Answer 2

你可以这样做：

uint32_t u;
int32_t& s = (int32_t&) u;

然后你可以使用s和u互换2的补码，例如：

s = -1;
std::cout << u << '\n';     // 4294967295

---

在您的问题中，您询问65535但这是一个正数。 你可以这样做：

uint16_t u;
int16_t& s = (int16_t&) u;

u = 65535;
std::cout << s << '\n';    // -1

请注意，将65535（正数）分配给int16_t将是实现定义的行为，它不一定给出-1 。

与原有代码的问题是，它不允许别名char缓冲区long 。 （而且你可能会溢出你的缓冲区）。 但是，可以将整数类型别名为其对应的有符号/无符号类型。

Answer 3

通常，当您有两个大小相同的算术类型并且您想要使用另一个类型重新解释一个的位表示时，可以使用union ：

#include <stdint.h>

union reinterpret_u64_d_union {
    uint64_t u64;
    double   d;
};

double
reinterpret_u64_as_double(uint64_t v)
{
    union reinterpret_u64_d_union u;
    u.u64 = v;
    return u.d;
}

但是，对于将无符号数转换为具有相同大小的带符号类型（反之亦然）的特殊情况，您可以使用传统的强制转换：

int64_t
reinterpret_u64_as_i64(uint64_t v)
{
    return (int64_t)v;
}

（对于[u]int64_t ，并不严格要求[u]int64_t ，但是如果你没有明确地编写[u]int64_t转换，并且你之间转换的类型很小，则可能涉及“整数提升”，这通常是不合需要的。）

您尝试这样做的方式违反了指针别名规则并引发了未定义的行为。

在C ++中，请注意reinterpret_cast<> 不会执行union所做的事情; 应用于算术类型时，它与static_cast<>相同。

在C ++中，还要注意上面使用的union依赖于1999 C标准中的规则（使用corrigienda），这个规则在我检查的时候还没有正式合并到C ++标准中; 但是，我熟悉的所有编译器都会按照您的期望进行。

最后，在C和C ++中， long和unsigned long保证能够分别代表至少 -2,147,483,647 ... 214,7483,647和0 ... 4,294,967,295。 您的测试程序使用65535，保证可以通过long和unsigned long来表示，因此，无论您如何操作，该值都将保持不变。 好吧，除非你使用了无效的指针别名，编译器决定让恶魔飞出你的鼻子。