printf16進数または8進数として印刷できます。バイナリまたは任意の基数として印刷するフォーマットタグはありますか？
gccを実行しています。
printf("%d %x %o\n", 10, 10, 10); //prints "10 A 12\n"
print("%b\n", 10); // prints "%b\n"
Brian
質問する
1006275 次
56 に答える
322
ハッキーですが、私のために働きます：
#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte) \
(byte & 0x80 ? '1' : '0'), \
(byte & 0x40 ? '1' : '0'), \
(byte & 0x20 ? '1' : '0'), \
(byte & 0x10 ? '1' : '0'), \
(byte & 0x08 ? '1' : '0'), \
(byte & 0x04 ? '1' : '0'), \
(byte & 0x02 ? '1' : '0'), \
(byte & 0x01 ? '1' : '0')
printf("Leading text "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(byte));
マルチバイト型の場合
printf("m: "BYTE_TO_BINARY_PATTERN" "BYTE_TO_BINARY_PATTERN"\n",
BYTE_TO_BINARY(m>>8), BYTE_TO_BINARY(m));
残念ながら、すべての余分な引用符が必要です。このアプローチには、マクロの効率上のリスクがあります ( の引数として関数を渡さないでくださいBYTE_TO_BINARY) が、メモリの問題と、ここにある他の提案のいくつかでの strcat の複数の呼び出しを回避します。
于 2010-07-08T22:07:56.880 に答える
226
Print Binary for Any Datatype
// Assumes little endian
void printBits(size_t const size, void const * const ptr)
{
unsigned char *b = (unsigned char*) ptr;
unsigned char byte;
int i, j;
for (i = size-1; i >= 0; i--) {
for (j = 7; j >= 0; j--) {
byte = (b[i] >> j) & 1;
printf("%u", byte);
}
}
puts("");
}
Test:
int main(int argv, char* argc[])
{
int i = 23;
uint ui = UINT_MAX;
float f = 23.45f;
printBits(sizeof(i), &i);
printBits(sizeof(ui), &ui);
printBits(sizeof(f), &f);
return 0;
}
于 2010-10-20T01:37:58.443 に答える
161
これは、あなたがやりたいことをするためのテクニックを示すための簡単なハックです。
#include <stdio.h> /* printf */
#include <string.h> /* strcat */
#include <stdlib.h> /* strtol */
const char *byte_to_binary
(
int x
)
{
static char b[9];
b[0] = '\0';
int z;
for (z = 128; z > 0; z >>= 1)
{
strcat(b, ((x & z) == z) ? "1" : "0");
}
return b;
}
int main
(
void
)
{
{
/* binary string to int */
char *tmp;
char *b = "0101";
printf("%d\n", strtol(b, &tmp, 2));
}
{
/* byte to binary string */
printf("%s\n", byte_to_binary(5));
}
return 0;
}
于 2008-09-22T02:59:20.920 に答える
90
通常、glibcにはバイナリ変換指定子はありません。
glibcのprintf（）関数ファミリーにカスタム変換タイプを追加することができます。詳細については、 register_printf_functionを参照してください。アプリケーションコードを単純化して利用できるようにする場合は、独自に使用するカスタム％b変換を追加できます。
これは、glibcでカスタムprintf形式を実装する方法の例です。
于 2008-09-22T02:53:38.873 に答える
59
小さなテーブルを使用して速度を向上させることができます1。同様の手法は、バイトを反転するなど、組み込みの世界で役立ちます。
const char *bit_rep[16] = {
[ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
[ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
[ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
[12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};
void print_byte(uint8_t byte)
{
printf("%s%s", bit_rep[byte >> 4], bit_rep[byte & 0x0F]);
}
1私は主に、オプティマイザーがそれほど積極的ではなく、速度の違いが目に見える組み込みアプリケーションについて言及しています。
于 2013-11-10T01:05:33.303 に答える
40
最下位ビットを出力し、右にシフトアウトします。整数がゼロになるまでこれを行うと、先行ゼロなしで逆の順序でバイナリ表現が出力されます。再帰を使用すると、順序を非常に簡単に修正できます。
#include <stdio.h>
void print_binary(unsigned int number)
{
if (number >> 1) {
print_binary(number >> 1);
}
putc((number & 1) ? '1' : '0', stdout);
}
私にとって、これは問題に対する最もクリーンな解決策の 1 つです。0bプレフィックスと末尾の改行文字が好きな場合は、関数をラップすることをお勧めします。
于 2014-12-23T19:46:01.957 に答える
19
これは、再入可能性の問題や引数のサイズ/タイプの制限に悩まされていない関数のバージョンです。
#define FMT_BUF_SIZE (CHAR_BIT*sizeof(uintmax_t)+1)
char *binary_fmt(uintmax_t x, char buf[static FMT_BUF_SIZE])
{
char *s = buf + FMT_BUF_SIZE;
*--s = 0;
if (!x) *--s = '0';
for (; x; x /= 2) *--s = '0' + x%2;
return s;
}
このコードは、2を目的のベースに置き換えるだけで、2〜10の任意のベースでも同様に機能することに注意してください。使用法は次のとおりです。
char tmp[FMT_BUF_SIZE];
printf("%s\n", binary_fmt(x, tmp));
x積分式はどこにありますか。
于 2011-01-29T21:34:05.763 に答える
13
const char* byte_to_binary(int x)
{
static char b[sizeof(int)*8+1] = {0};
int y;
long long z;
for (z = 1LL<<sizeof(int)*8-1, y = 0; z > 0; z >>= 1, y++) {
b[y] = (((x & z) == z) ? '1' : '0');
}
b[y] = 0;
return b;
}
于 2009-03-18T06:57:47.860 に答える
12
バイナリ形式で印刷する printf コンバーターはありますか?
このprintf()ファミリは、標準指定子を直接使用して、基数 8、10、および 16 の整数のみを出力できます。コードの特定のニーズに応じて、数値を文字列に変換する関数を作成することをお勧めします。
任意のベースで印刷するには [2-36]
これまでの他のすべての回答には、これらの制限の少なくとも 1 つがあります。
戻りバッファには静的メモリを使用します。これにより、関数が の引数として使用できる回数が制限されます
printf()。呼び出し元のコードがポインターを解放する必要があるメモリを割り当てます。
適切なバッファを明示的に提供する呼び出しコードを要求します。
printf()直接電話してください。これにより、 tofprintf()、sprintf()、vsprintf()などに新しい関数が必要になります。縮小された整数範囲を使用してください。
以下は、上記の制限のいずれもありません。C99 以降と の使用が必要です"%s"。複合リテラルを使用してバッファー スペースを提供します。で複数回呼び出しても問題ありませんprintf()。
#include <assert.h>
#include <limits.h>
#define TO_BASE_N (sizeof(unsigned)*CHAR_BIT + 1)
// v--compound literal--v
#define TO_BASE(x, b) my_to_base((char [TO_BASE_N]){""}, (x), (b))
// Tailor the details of the conversion function as needed
// This one does not display unneeded leading zeros
// Use return value, not `buf`
char *my_to_base(char buf[TO_BASE_N], unsigned i, int base) {
assert(base >= 2 && base <= 36);
char *s = &buf[TO_BASE_N - 1];
*s = '\0';
do {
s--;
*s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i % base];
i /= base;
} while (i);
// Could employ memmove here to move the used buffer to the beginning
// size_t len = &buf[TO_BASE_N] - s;
// memmove(buf, s, len);
return s;
}
#include <stdio.h>
int main(void) {
int ip1 = 0x01020304;
int ip2 = 0x05060708;
printf("%s %s\n", TO_BASE(ip1, 16), TO_BASE(ip2, 16));
printf("%s %s\n", TO_BASE(ip1, 2), TO_BASE(ip2, 2));
puts(TO_BASE(ip1, 8));
puts(TO_BASE(ip1, 36));
return 0;
}
出力
1020304 5060708
1000000100000001100000100 101000001100000011100001000
100401404
A2F44
于 2016-01-06T19:57:42.260 に答える
12
以前に投稿された回答はどれも、まさに私が探していたものではないので、私はそれを書きました. %Bを使用するのは非常に簡単printfです。
/*
* File: main.c
* Author: Techplex.Engineer
*
* Created on February 14, 2012, 9:16 PM
*/
#include <stdio.h>
#include <stdlib.h>
#include <printf.h>
#include <math.h>
#include <string.h>
static int printf_arginfo_M(const struct printf_info *info, size_t n, int *argtypes)
{
/* "%M" always takes one argument, a pointer to uint8_t[6]. */
if (n > 0) {
argtypes[0] = PA_POINTER;
}
return 1;
}
static int printf_output_M(FILE *stream, const struct printf_info *info, const void *const *args)
{
int value = 0;
int len;
value = *(int **) (args[0]);
// Beginning of my code ------------------------------------------------------------
char buffer [50] = ""; // Is this bad?
char buffer2 [50] = ""; // Is this bad?
int bits = info->width;
if (bits <= 0)
bits = 8; // Default to 8 bits
int mask = pow(2, bits - 1);
while (mask > 0) {
sprintf(buffer, "%s", ((value & mask) > 0 ? "1" : "0"));
strcat(buffer2, buffer);
mask >>= 1;
}
strcat(buffer2, "\n");
// End of my code --------------------------------------------------------------
len = fprintf(stream, "%s", buffer2);
return len;
}
int main(int argc, char** argv)
{
register_printf_specifier('B', printf_output_M, printf_arginfo_M);
printf("%4B\n", 65);
return EXIT_SUCCESS;
}
于 2012-02-15T03:39:20.423 に答える
10
このコードは、最大 64 ビットのニーズを処理する必要があります。と の 2 つの関数を作成pBinしましpBinFillた。どちらも同じことを行いpBinFillますが、最後の引数で指定された埋め込み文字で先頭のスペースを埋めます。test 関数はいくつかのテスト データを生成し、関数を使用してそれを出力しpBinFillます。
#define kDisplayWidth 64
char* pBin(long int x,char *so)
{
char s[kDisplayWidth+1];
int i = kDisplayWidth;
s[i--] = 0x00; // terminate string
do { // fill in array from right to left
s[i--] = (x & 1) ? '1' : '0'; // determine bit
x >>= 1; // shift right 1 bit
} while (x > 0);
i++; // point to last valid character
sprintf(so, "%s", s+i); // stick it in the temp string string
return so;
}
char* pBinFill(long int x, char *so, char fillChar)
{
// fill in array from right to left
char s[kDisplayWidth+1];
int i = kDisplayWidth;
s[i--] = 0x00; // terminate string
do { // fill in array from right to left
s[i--] = (x & 1) ? '1' : '0';
x >>= 1; // shift right 1 bit
} while (x > 0);
while (i >= 0) s[i--] = fillChar; // fill with fillChar
sprintf(so, "%s", s);
return so;
}
void test()
{
char so[kDisplayWidth+1]; // working buffer for pBin
long int val = 1;
do {
printf("%ld =\t\t%#lx =\t\t0b%s\n", val, val, pBinFill(val, so, '0'));
val *= 11; // generate test data
} while (val < 100000000);
}
出力：
00000001 = 0x000001 = 0b00000000000000000000000000000001
00000011 = 0x00000b = 0b00000000000000000000000000001011
00000121 = 0x000079 = 0b00000000000000000000000001111001
00001331 = 0x000533 = 0b00000000000000000000010100110011
00014641 = 0x003931 = 0b00000000000000000011100100110001
00161051 = 0x02751b = 0b00000000000000100111010100011011
01771561 = 0x1b0829 = 0b00000000000110110000100000101001
19487171 = 0x12959c3 = 0b00000001001010010101100111000011
于 2009-07-03T08:45:42.830 に答える
7
C標準ライブラリには、そのようなバイナリを出力するためのフォーマット機能はありません。printfファミリがサポートするすべてのフォーマット操作は、人間が読めるテキストを対象としています。
于 2008-09-21T20:09:35.523 に答える
7
一部のランタイムは「％b」をサポートしていますが、これは標準ではありません。
興味深い議論については、こちらも参照してください。
http://bytes.com/forum/thread591027.html
HTH
于 2008-09-21T20:11:16.250 に答える
7
少しOTかもしれませんが、実行中のバイナリ操作を理解または追跡するためにデバッグするためだけにこれが必要な場合は、wcalc（単純なコンソール計算機）を見てください。-b オプションを使用すると、バイナリ出力が得られます。
例えば
$ wcalc -b "(256 | 3) & 0xff" = 0b11
于 2008-09-22T08:25:57.420 に答える
6
次の再帰関数が役立つ場合があります。
void bin(int n)
{
/* Step 1 */
if (n > 1)
bin(n/2);
/* Step 2 */
printf("%d", n % 2);
}
于 2015-03-01T17:48:35.147 に答える
5
使用する：
char buffer [33];
itoa(value, buffer, 2);
printf("\nbinary: %s\n", buffer);
詳細については、 printfを介して2進数を印刷する方法を参照してください。
于 2012-10-19T12:50:02.630 に答える
5
より少ないコードとリソースを使用して、任意の型からビットを出力します
このアプローチには、次の属性があります。
- 変数とリテラルで動作します。
- 必要がない場合、すべてのビットを反復しません。
- 1 バイトが完了した場合にのみ、printf を呼び出します (すべてのビットに対して不必要ではありません)。
- どのタイプにも効きます。
- リトル エンディアンとビッグ エンディアンで動作します (チェックには GCC #defines を使用します)。
- char がバイト (8 ビット) ではないハードウェアで動作する可能性があります。(Tks @supercat)
- C 標準ではありませんが、広く定義されている typeof() を使用します。
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <limits.h>
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define for_endian(size) for (int i = 0; i < size; ++i)
#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define for_endian(size) for (int i = size - 1; i >= 0; --i)
#else
#error "Endianness not detected"
#endif
#define printb(value) \
({ \
typeof(value) _v = value; \
__printb((typeof(_v) *) &_v, sizeof(_v)); \
})
#define MSB_MASK 1 << (CHAR_BIT - 1)
void __printb(void *value, size_t size)
{
unsigned char uc;
unsigned char bits[CHAR_BIT + 1];
bits[CHAR_BIT] = '\0';
for_endian(size) {
uc = ((unsigned char *) value)[i];
memset(bits, '0', CHAR_BIT);
for (int j = 0; uc && j < CHAR_BIT; ++j) {
if (uc & MSB_MASK)
bits[j] = '1';
uc <<= 1;
}
printf("%s ", bits);
}
printf("\n");
}
int main(void)
{
uint8_t c1 = 0xff, c2 = 0x44;
uint8_t c3 = c1 + c2;
printb(c1);
printb((char) 0xff);
printb((short) 0xff);
printb(0xff);
printb(c2);
printb(0x44);
printb(0x4411ff01);
printb((uint16_t) c3);
printb('A');
printf("\n");
return 0;
}
出力
$ ./printb
11111111
11111111
00000000 11111111
00000000 00000000 00000000 11111111
01000100
00000000 00000000 00000000 01000100
01000100 00010001 11111111 00000001
00000000 01000011
00000000 00000000 00000000 01000001
別のアプローチ ( bitprint.h ) を使用して、テーブルにすべてのバイト (ビット文字列として) を入力し、入力/インデックス バイトに基づいてそれらを出力しました。一見の価値があります。
于 2016-09-08T22:55:54.743 に答える
3
私はpaniqのコードが好きでした。静的バッファーは良い考えです。ただし、単一のprintf（）で複数のバイナリ形式が必要な場合は、常に同じポインタを返し、配列を上書きするため、失敗します。
これは、分割バッファー上でポインターを回転させるCスタイルのドロップインです。
char *
format_binary(unsigned int x)
{
#define MAXLEN 8 // width of output format
#define MAXCNT 4 // count per printf statement
static char fmtbuf[(MAXLEN+1)*MAXCNT];
static int count = 0;
char *b;
count = count % MAXCNT + 1;
b = &fmtbuf[(MAXLEN+1)*count];
b[MAXLEN] = '\0';
for (int z = 0; z < MAXLEN; z++) { b[MAXLEN-1-z] = ((x>>z) & 0x1) ? '1' : '0'; }
return b;
}
于 2011-08-21T09:45:38.053 に答える
3
標準的でポータブルな方法はありません。
一部の実装ではitoa()が提供されていますが、ほとんどの実装では提供されておらず、インターフェイスがやや粗雑です。しかし、コードはリンクの背後にあり、独自のフォーマッターを非常に簡単に実装できるはずです。
于 2008-09-21T20:45:42.330 に答える
3
標準ライブラリを使用して、任意の整数型をバイナリ文字列表現に汎用変換する1 つのステートメント:
#include <bitset>
MyIntegralType num = 10;
print("%s\n",
std::bitset<sizeof(num) * 8>(num).to_string().insert(0, "0b").c_str()
); // prints "0b1010\n"
あるいは単に： std::cout << std::bitset<sizeof(num) * 8>(num);
于 2015-07-27T18:13:18.140 に答える
3
void print_ulong_bin(const unsigned long * const var, int bits) {
int i;
#if defined(__LP64__) || defined(_LP64)
if( (bits > 64) || (bits <= 0) )
#else
if( (bits > 32) || (bits <= 0) )
#endif
return;
for(i = 0; i < bits; i++) {
printf("%lu", (*var >> (bits - 1 - i)) & 0x01);
}
}
動作するはずです - テストされていません。
于 2010-09-30T10:47:50.543 に答える
3
unsigned int に対して行った方法は次のとおりです
void printb(unsigned int v) {
unsigned int i, s = 1<<((sizeof(v)<<3)-1); // s = only most significant bit at 1
for (i = s; i; i>>=1) printf("%d", v & i || 0 );
}
于 2014-08-26T09:33:59.837 に答える
2
ビット操作の問題を解決しながらこれを行う C の小さなユーティリティ関数。これは、マスク (1<
void
printStringAsBinary(char * input)
{
char * temp = input;
int i = 7, j =0;;
int inputLen = strlen(input);
/* Go over the string, check first bit..bit by bit and print 1 or 0
**/
for (j = 0; j < inputLen; j++) {
printf("\n");
while (i>=0) {
if (*temp & (1 << i)) {
printf("1");
} else {
printf("0");
}
i--;
}
temp = temp+1;
i = 7;
printf("\n");
}
}
于 2014-10-02T04:37:06.647 に答える
2
次に、メモリ レイアウトが表示されます。
#include <limits>
#include <iostream>
#include <string>
using namespace std;
template<class T> string binary_text(T dec, string byte_separator = " ") {
char* pch = (char*)&dec;
string res;
for (int i = 0; i < sizeof(T); i++) {
for (int j = 1; j < 8; j++) {
res.append(pch[i] & 1 ? "1" : "0");
pch[i] /= 2;
}
res.append(byte_separator);
}
return res;
}
int main() {
cout << binary_text(5) << endl;
cout << binary_text(.1) << endl;
return 0;
}
于 2012-01-15T10:57:58.887 に答える
2
/* Convert an int to it's binary representation */
char *int2bin(int num, int pad)
{
char *str = malloc(sizeof(char) * (pad+1));
if (str) {
str[pad]='\0';
while (--pad>=0) {
str[pad] = num & 1 ? '1' : '0';
num >>= 1;
}
} else {
return "";
}
return str;
}
/* example usage */
printf("The number 5 in binary is %s", int2bin(5, 4));
/* "The number 5 in binary is 0101" */
于 2011-07-01T10:22:15.103 に答える
2
バイナリで印刷するさらに別のアプローチ:整数を最初に変換します。
6バイナリで印刷するには、 に変更6してから110を印刷します"110"。
問題を回避char buf[]します。
printf()フォーマット指定子、フラグ、および のようなフィールドは"%08lu"、"%*lX"まだすぐに使用できます。
バイナリ (基数 2) だけでなく、このメソッドは 16 までの他の基数に拡張でき
ます。小さい整数値に限定されます。
#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>
unsigned long char_to_bin10(char ch) {
unsigned char uch = ch;
unsigned long sum = 0;
unsigned long power = 1;
while (uch) {
if (uch & 1) {
sum += power;
}
power *= 10;
uch /= 2;
}
return sum;
}
uint64_t uint16_to_bin16(uint16_t u) {
uint64_t sum = 0;
uint64_t power = 1;
while (u) {
if (u & 1) {
sum += power;
}
power *= 16;
u /= 2;
}
return sum;
}
void test(void) {
printf("%lu\n", char_to_bin10(0xF1));
// 11110001
printf("%" PRIX64 "\n", uint16_to_bin16(0xF731));
// 1111011100110001
}
于 2013-11-12T21:15:31.523 に答える
2
私は自分のソリューションを投稿したいだけです。1 バイトのゼロと 1 を取得するために使用されますが、この関数を数回呼び出すと、より大きなデータ ブロックに使用できます。128 ビット以上の構造体に使用します。size_t を入力パラメーターとして使用し、印刷するデータへのポインターを使用するように変更して、サイズに依存しないようにすることもできます。しかし、それは私にとってはうまくいきます。
void print_binary(unsigned char c)
{
unsigned char i1 = (1 << (sizeof(c)*8-1));
for(; i1; i1 >>= 1)
printf("%d",(c&i1)!=0);
}
void get_binary(unsigned char c, unsigned char bin[])
{
unsigned char i1 = (1 << (sizeof(c)*8-1)), i2=0;
for(; i1; i1>>=1, i2++)
bin[i2] = ((c&i1)!=0);
}
于 2014-03-19T15:52:27.823 に答える
2
#include <stdio.h>
#include <conio.h>
void main()
{
clrscr();
printf("Welcome\n\n\n");
unsigned char x='A';
char ch_array[8];
for(int i=0; x!=0; i++)
{
ch_array[i] = x & 1;
x = x >>1;
}
for(--i; i>=0; i--)
printf("%d", ch_array[i]);
getch();
}
于 2010-10-24T10:07:56.490 に答える
1
void print_bits (uintmax_t n)
{
for (size_t i = 8 * sizeof (int); i-- != 0;)
{
char c;
if ((n & (1UL << i)) != 0)
c = '1';
else
c = '0';
printf ("%c", c);
}
}
絶対にどこでもカバーするソリューションではありませんが、迅速で理解しやすいものが必要な場合は、このソリューションをまだ誰も提案していないことに驚いています.
于 2021-02-21T01:09:46.257 に答える
1
数値を 16 進数形式に変換してから、各 16 進数暗号を 4 つの「ビット」(1 と 0) にデコードするというアイデアもあります。sprintf私たちのためにビット操作を行うことができます:
const char* binary(int n) {
static const char binnums[16][5] = { "0000","0001","0010","0011",
"0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111" };
static const char* hexnums = "0123456789abcdef";
static char inbuffer[16], outbuffer[4*16];
const char *i;
sprintf(inbuffer,"%x",n); // hexadecimal n -> inbuffer
for(i=inbuffer; *i!=0; ++i) { // for each hexadecimal cipher
int d = strchr(hexnums,*i) - hexnums; // store its decimal value to d
char* o = outbuffer+(i-inbuffer)*4; // shift four characters in outbuffer
sprintf(o,"%s",binnums[d]); // place binary value of d there
}
return strchr(outbuffer,'1'); // omit leading zeros
}
puts(binary(42)); // outputs 101010
于 2017-02-15T11:23:48.130 に答える
1
私のソリューションはintを返し、それをprintfで使用できます。ビッグ エンディアンまたはリトルエンディアンの順序でビットを返すこともできます。
#include <stdio.h>
#include <stdint.h>
int binary(uint8_t i,int bigEndian)
{
int j=0,m = bigEndian ? 1 : 10000000;
while (i)
{
j+=m*(i%2);
if (bigEndian) m*=10; else m/=10;
i >>= 1;
}
return j;
}
int main()
{
char buf[]="ABCDEF";
printf("\nbig endian = ");
for (int i=0; i<5; i++) printf("%08d ",binary(buf[i],1));
printf("\nwee endian = ");
for (int i=0; i<5; i++) printf("%08d ",binary(buf[i],0));
getchar();
return 0;
}
出力
big endian = 01000001 01000010 01000011 01000100 01000101 01000110
wee endian = 10000010 01000010 11000010 00100010 10100010 01100010
于 2020-06-08T15:38:33.770 に答える
0
％bをサポートするランタイムライブラリの場合でも、整数値のみのようです。
浮動小数点値をバイナリで出力したい場合は、http：//www.exploringbinary.com/converting-floating-point-numbers-to-binary-strings-in-c/にあるコードをいくつか作成しました。
于 2009-05-06T14:54:32.680 に答える
0
バイナリ形式で印刷するためのprintfコンバーターはありますか？
「バイナリ」出力を実現するための標準のprintfフォーマット指定子はありません。これが私が必要なときに考案した代替案です。
Mineは、2から36までの任意のベースで機能します。ベースよりも小さい数字に達するまで、再帰呼び出しの呼び出しフレームに数字を広げます。次に、後方に「トラバース」し、バッファを前方に埋めて戻ります。戻り値は、使用されるサイズです。バッファが文字列を保持するのに十分な大きさでない場合は-1です。
int conv_rad (int num, int rad, char *s, int n) {
char *vec = "0123456789" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ";
int off;
if (n == 0) return 0;
if (num < rad) { *s = vec[num]; return 1; }
off = conv_rad(num/rad, rad, s, n);
if ((off == n) || (off == -1)) return -1;
s[off] = vec[num%rad];
return off+1;
}
1つの大きな注意点：この関数は、長さを運ぶ「パスカル」スタイルのストリングで使用するために設計されました。したがってconv_rad、記述されているように、バッファを無効にすることはありません。より一般的なCの使用法の場合、nul-terminateするための単純なラッパーがおそらく必要になります。または、印刷の場合は、割り当てをputchar()sに変更するだけです。
于 2011-07-21T01:51:11.647 に答える
0
あまり効率的ではないかもしれませんが、非常に単純です。これを試して：
tmp1 = 1;
while(inint/tmp1 > 1) {
tmp1 <<= 1;
}
do {
printf("%d", tmp2=inint/tmp1);
inint -= tmp1*tmp2;
} while((tmp1 >>= 1) > 0);
printf(" ");
于 2013-06-29T13:38:29.090 に答える
0
これは非常に単純なものです：
int print_char_to_binary(char ch)
{
int i;
for (i=7; i>=0; i--)
printf("%hd ", ((ch & (1<<i))>>i));
printf("\n");
return 0;
}
于 2013-10-19T19:26:35.563 に答える
0
次の関数は、先行ゼロなしでポインター演算を使用して、指定された符号なし整数のバイナリ表現を返します。
const char* toBinaryString(unsigned long num)
{
static char buffer[CHAR_BIT*sizeof(num)+1];
char* pBuffer = &buffer[sizeof(buffer)-1];
do *--pBuffer = '0' + (num & 1);
while (num >>= 1);
return pBuffer;
}
NULターミネータを明示的に設定する必要がないことに注意してください。これは、静的ストレージ期間bufferを持つオブジェクトを表し、すでにすべてゼロで埋められているためです。
これは、仮パラメータunsigned long longの型を変更するだけで (または別の符号なし整数)に簡単に適応させることができます。num
CHAR_BITを含める必要があります<limits.h>。
使用例を次に示します。
int main(void)
{
printf(">>>%20s<<<\n", toBinaryString(1));
printf(">>>%-20s<<<\n", toBinaryString(254));
return 0;
}
望ましい出力は次のとおりです。
>>> 1<<<
>>>11111110 <<<
于 2016-01-09T00:40:50.240 に答える
0
void PrintBinary( int Value, int Places, char* TargetString)
{
int Mask;
Mask = 1 << Places;
while( Places--) {
Mask >>= 1; /* Preshift, because we did one too many above */
*TargetString++ = (Value & Mask)?'1':'0';
}
*TargetString = 0; /* Null terminator for C string */
}
呼び出し元の関数は文字列を「所有」しています...:
char BinaryString[17];
...
PrintBinary( Value, 16, BinaryString);
printf( "yadda yadda %s yadda...\n", BinaryString);
CPU に応じて、PrintBinary のほとんどの操作は、1 つまたは非常に少数のマシン命令にレンダリングされます。
于 2010-10-21T16:54:08.817 に答える