如何将超int范围整数转为二进制并实现补码转换？

Great question! You’ve already fixed the integer overflow issue by switching from int to uint64_t, which is a solid first step. Now, let’s tackle the 2's complement conversion—first, a quick key point: 2's complement is a signed integer representation, so if you want to handle negative values properly, you should use int64_t (signed 64-bit integer) as your parameter type instead of uint64_t.

First, let’s fix a small bug in your existing code: your malloc call is incorrect. sizeof(digit) returns 8 (since uint64_t is 8 bytes), so sizeof(digit)*64 allocates 512 bytes—way more than needed. We only need to store 64 binary bits, so use malloc(64 * sizeof(char)) instead, and always remember to free the memory to avoid leaks.

Method 1: Bitwise Operation (Most Efficient & Clean) #

The simplest way to output the 2's complement of a signed 64-bit integer is to directly read each bit from memory (since signed integers are stored as 2's complement in memory). We can use bitwise shifts to extract each bit from the highest (63rd) to lowest (0th) position:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h> // For PRIu64 format specifier

void int64ToComplementBin(int64_t digit) {
    printf("64-bit 2's complement: ");
    
    // Iterate from the highest bit (63) to the lowest (0)
    for (int i = 63; i >= 0; i--) {
        // Cast to uint64_t to avoid arithmetic right shift issues with negative numbers
        uint64_t bit = ((uint64_t)digit >> i) & 1;
        printf("%" PRIu64, bit);
        
        // Add a space every 4 bits for readability (optional)
        if (i % 4 == 0) {
            printf(" ");
        }
    }
    printf("\n");
}

How this works: #

• Casting digit to uint64_t ensures we do a logical right shift (fill with 0s) instead of arithmetic right shift (fill with 1s for negatives)—though even arithmetic shift would work here, casting makes the behavior explicit.
• (digit >> i) shifts the number right by i positions, moving the bit we want to the 0th position.
• & 1 isolates that bit (0 or 1) for output.
• This method outputs the full 64 bits, including leading zeros for positive numbers and leading 1s for negative numbers (which is the correct 2's complement representation).

Method 2: Adapt Your Existing Division/Remainder Logic #

If you prefer to stick with your original approach of dividing by 2 and collecting remainders, you’ll need to handle negative values by converting them to their unsigned 2's complement equivalent first:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

void int64ToComplementBinLegacy(int64_t digit) {
    int k = 0;
    // Allocate enough space for 64 bits
    char *bits = malloc(64 * sizeof(char));
    if (!bits) {
        perror("Failed to allocate memory");
        return;
    }

    uint64_t u_digit;
    if (digit < 0) {
        // For negative numbers, 2's complement is equal to 2^64 + digit
        u_digit = (uint64_t)(1ULL << 64) + digit;
    } else {
        u_digit = (uint64_t)digit;
    }

    // Collect bits from least significant to most
    while (u_digit > 0) {
        bits[k++] = u_digit % 2;
        u_digit /= 2;
    }

    printf("64-bit 2's complement: ");
    // Print leading zeros to fill 64 bits
    for (int i = 64 - k; i > 0; i--) {
        printf("0");
    }
    // Print collected bits in reverse order (most significant first)
    for (int i = k - 1; i >= 0; i--) {
        printf("%d", bits[i]);
    }
    printf("\n");

    free(bits); // Clean up allocated memory
}

How this works: #

• Negative int64_t values can be converted to their unsigned 2's complement form by calculating 2^64 + digit (since the range of int64_t is -2^63 to 2^63 - 1).
• We then process this unsigned value using your original division/remainder logic to collect bits.
• Finally, we add leading zeros to ensure we output a full 64-bit representation.

Usage Example #

int main() {
    int64_t positive_num = 10329216702565230;
    int64_t negative_num = -10329216702565230;

    int64ToComplementBin(positive_num);
    int64ToComplementBin(negative_num);

    int64ToComplementBinLegacy(positive_num);
    int64ToComplementBinLegacy(negative_num);

    return 0;
}

Key Takeaways: #

• Use int64_t for signed 64-bit integers when working with 2's complement.
• Bitwise operations are faster and more straightforward for direct 2's complement output.
• Always validate malloc results and free allocated memory to prevent leaks.

内容的提问来源于stack exchange，提问作者start01