而不是打印二進制數，我將如何將它作爲一個變量存儲？

Question

我將一個十六進制數字傳遞到hex2bin中，它將正確地打印出二進制數字，但我不希望它打印出我想返回數字的數字，以便我可以使用它來查找數字的基數。我將如何存儲該號碼而不是將其打印出來？

int hex2bin (int n){ 
    int i,k,mask; 
    for(i = sizeof(int) * 8 - 1; i >= 0; i--){ 
     mask = 1 << i; 
     k = n & mask; 
     k == 0 ? printf("0"):printf("1"); 
    } 
    return 0; 
} 

Answer 1

也許是這樣的？

int result = 0; 
int i, k... 
... 
result = result | (((k == 0) ? 0 : 1) << i; 
... 
return result; 

而不是被巧妙搭配一個int，你當然也可以簡單地使用數組變量來代替。

Answer 2

您可以使用strcat函數來做到這一點。

注意，在這個答案的新hex2bin函數假設參數char *buf已被分配，可容納至少1+sizeof(int)*8字節包括空終止：

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

// assume: buf is at least length 33 
int hex2bin (int n, char *buf) 
{ 
    int i,k,mask; 
    for(i = sizeof(int) * 8 - 1; i >= 0; i--){ 
     mask = 1 << i; 
     k = n & mask; 
     k == 0 ? strcat(buf, "0") : strcat(buf, "1"); 
    } 
    return 0; 
} 

int main() 
{ 
    int n = 66555; 
    char buffer[1+sizeof(int)*8] = { 0 } ; 
    hex2bin(n, buffer); 
    printf("%s\n", buffer); 
    return 0; 
} 

Answer 3

存儲在一個字符串，其空間是多少由複合文字提供（自C99起可用）。

它的工作原理類似於OP的流程：循環至sizeof(int) * 8次，找到1位的值並打印/保存。

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

// Maximum buffer size needed 
#define UTOA_BASE_2 (sizeof(unsigned)*CHAR_BIT + 1) 

char *utoa_base2(char *s, unsigned x) { 
    s += UTOA_BASE_2 - 1; 
    *s = '\0'; 
    do { 
    *(--s) = "01"[x % 2]; 
    x /= 2; 
    } while (x); 
    return s; 
} 

#define TO_BASE2(x) utoa_base2((char [UTOA_BASE_2]){0} , (x)) 

void test(unsigned x) { 
    printf("base10:%10u base2:%5s ", x, TO_BASE2(x)); 
    char *s = TO_BASE2(x); 
    // do stuff with `s`, it is valid for until the end of this block 
    printf("%s\n", s); 
} 

int main(void) { 
    test(0); 
    test(25); 
    test(UINT_MAX); 
} 

樣本輸出

base10:   0 base2: 0 0 
base10:  25 base2:11001 11001 
base10:4294967295 base2:11111111111111111111111111111111 11111111111111111111111111111111 

這是此base-n answer的變體。

Answer 4

我希望你能有所幫助:)

bool convertDecimalBNR(INT32 nDecimalValue, UINT32 * punFieldValue, INT32 nBitCount, DecimalBNRType * pDecimalSpecification) 
{ 
    bool bBNRConverted = false; 
    INT32 nBitIndex = nBitCount - 1; 
    INT32 nBitValue = anTwoExponents[nBitIndex]; 

    *punFieldValue = 0; 

    if ((nDecimalValue >= pDecimalSpecification->nMinValue) && (nDecimalValue <= pDecimalSpecification->nMaxValue)) 
    { 
     // if the value is negative, then add (-1 * (2^(nBitCount - 1))) on itself and go on just like a positive value calculation. 
    if (nDecimalValue < 0) 
    { 
     nDecimalValue += nBitValue; 
     nBitIndex--; 
     nBitValue /= 2; 
     *punFieldValue |= BIT_0_ONLY_ONE; 
    } 

    while (nBitIndex >= 0) 
    { 
     *punFieldValue = (*punFieldValue << 1); 

     if (nDecimalValue >= nBitValue) 
     { 
     nDecimalValue -= nBitValue; 
     *punFieldValue |= BIT_0_ONLY_ONE; 
     } 

     nBitIndex--; 
     nBitValue /= 2; 
    } 

    if (nDecimalValue <= nBitValue) 
    { 
     bBNRConverted = true; 
    } 
    } 

    return (bBNRConverted); 
}