blocks|key|4518677|text|有一种比您所做的简单得多的方法：num+&+0x0f将获得最后四个数，然后您只需使用printf("%2504b\n",+num+&0x0f);以二进制形式打印它。编辑：%25b说明符不是标准的！那么可能不应该使用它，而是使用下面的示例。/edit|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4518678|任何十六进制的f都是二进制的1111，这使得提取这些四位数变得很容易。如果你不能只使用printf，你也可以很容易地打印出来，一次屏蔽一个，然后将数字移位以排列另一个来显示。例如：|4518679|for(int+i+=+0;+i+<+4;+i%2B%2B)+{
++++printf("%25c",+(number+&+8)+?+'1'+:+'0');+//+print+the+number+on+the+left+of+the+quartet
++++number+<<=+1;+//+shift+it+to+the+right+by+one+position,+putting+the+next+bit+in+position+to+print+next+loop+around
}|code-block|syntax|javascript|4518680|位操作中的其他有用技巧是将1移位以获得掩码。要获得第#n位，从右开始，执行number+&+(1+<<+n)。一次左移0次是1-该掩码得到最低有效位(最右侧)。一次左移是两次，第二个最低有效位，依此类推。您的bit1+=+bit+<<+i代码行可以做到这一点，但我更喜欢使用文字1来说明它不必是一个变量。|4518681|entityMap^0|G|A|16|S|0|7|1|E|4|0|0|11|H|2W|F|3V|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|P|$]]

There's a much easier way than what you're doing: <code>num &amp; 0x0f</code> will get the last four, then you just print it in binary with <code>printf("%04b\n", num &amp;0x0f);</code>. EDIT: the %b specifier is non-standard! probably shouldn't use that then, instead go with the example below. /edit

Any <code>f</code> in hexadecimal is <code>1111</code> in binary which makes it easy to pull out those quartets. If you can't just use printf, you can also print a bit pretty easily by masking out one at a time, then shifting the number to line up another to display. For example:

<pre><code>for(int i = 0; i &lt; 4; i++) {
 printf("%c", (number &amp; 8) ? '1' : '0'); // print the number on the left of the quartet
 number &lt;&lt;= 1; // shift it to the right by one position, putting the next bit in position to print next loop around
}
</code></pre>

Other useful tricks in bit manipulation are shifting a one around to get a mask. To get bit #n, starting from the right, do <code>number &amp; (1 &lt;&lt; n)</code>. One shifted left zero times is one - that mask gets you the least significant (right-most) bit. One shifted left one time is two, the second least significant bit, and so on. Your <code>bit1 = bit &lt;&lt; i</code> line does this, but I prefer to use the literal <code>1</code> for this trick to make it clear that it doesn't have to be a variable.

blocks|key|3050840|text|如果您只想显示4位数，只需使用查找表，因为我们已经知道所有可能的表示形式。如果您想在其他位置显示另外4位数字，只需在num&0x0F之后进行移位，但掩码将是其他值而不是0x0F|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3050841|const+char+*+bin[16]+=+{
++++"0000",
++++"0001",
++++"0010",
++++......
++++"1111"
};

printf("%25s\n",+bin[num&0x0F]);|code-block|syntax|javascript|3050842|entityMap^0|1M|8|2C|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

If you only want to display 4 digits, just use look up table because we already know all the possible representations. 
If you want to display another 4 digits at other position, just do the shifting after <code>num&amp;0x0F</code>, but the mask will be other value instead of <code>0x0F</code>

<pre><code>const char * bin[16] = {
 "0000",
 "0001",
 "0010",
 ......
 "1111"
};

printf("%s\n", bin[num&amp;0x0F]);
</code></pre>

blocks|key|3050896|text|num+&+0xF将提取最后一个for数字。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3050897|要打印最后4个，代码可以使用：|3050898|printf("%2504d",+(num&8)*125+%2B+(num&4)*25+%2B+(num&2)*5+%2B+(num&1));|code-block|syntax|javascript|3050899|另一种使用八进制的方法：|3050900|要打印最低有效的8，代码可以使用：|3050901|printf("%2508lo",+
+++(num&128)*16384LU+%2B+(num&64)*4096L+%2B+(num&32)*1024L+%2B+(num&16)*256+%2B
+++(num&8)*64+%2B+(num&4)*16+%2B+(num&2)*4+%2B+(num&1));|3050902|该方法使用多项方程或for循环，最多可处理21位和unsigned+long+long。|3050903|entityMap^0|0|9|0|0|0|0|0|0|A|3|P|I|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|13|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|V|$]]

<code>num &amp; 0xF</code> will extract the last for digits.

To print the last 4, code could use:

<pre><code>printf("%04d", (num&amp;8)*125 + (num&amp;4)*25 + (num&amp;2)*5 + (num&amp;1));
</code></pre>

Another approach using octal: 
To print the least significant 8, code could use:

<pre><code>printf("%08lo", 
 (num&amp;128)*16384LU + (num&amp;64)*4096L + (num&amp;32)*1024L + (num&amp;16)*256 +
 (num&amp;8)*64 + (num&amp;4)*16 + (num&amp;2)*4 + (num&amp;1));
</code></pre>

This method works with up to at least 21 bits and <code>unsigned long long</code> using a many term equation or <code>for</code> loop.

blocks|key|734905|text|The+following+function+extractAllBitsFromIntToArray
Parameters:
int+value:+the+source+integer+to+use+for+the+extraction
int*+totalBits:+pointer+to+callers'+area+to+receive+size+of+returned+int+array
Returns:
int*+a+pointer+to+a+malloc'd+array+that+contains+the+extracted+bits+from+'value'
+++++least+significant+bit+at+offset+0+into+the+array.
+++++note:+the+caller+must+'free()'+this+array+when+done+using+it++


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

#define+TOTAL_BITS+(sizeof(int)<<3)+//+assumes+8+bit+bytes
#define+BIT_MASK(count)+++(1<<count)

int+*+extractAllBitsFromIntToArray(+int+value,+int*+numBits)
{
++++int+i+=+0;+//+loop+counter
++++int+*pRetArray+=+NULL;
++++if(+NULL+==+(pRetArray+=+malloc(+TOTAL_BITS*sizeof(int))+)+)+//+array+to+return
++++{
++++++++perror(+"malloc+failed"+);
++++++++exit(+EXIT_FAILURE+);
++++}

++++memset(+pRetArray,+0x00,+TOTAL_BITS*sizeof(int)+);+//+clear+array

++++//+extract+bits,+where+pRetArray[0]+is+LSB
++++for(+i=0;+i<TOTAL_BITS;+i%2B%2B+)
++++{
++++++++pRetArray[i]+=+(value&(BIT_MASK(i)))?+1:
++++}

++++return(+pRetArray+);
}+//+end+function:+extractAllBitsFromIntToArray|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|734906|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>The following function extractAllBitsFromIntToArray
Parameters:
int value: the source integer to use for the extraction
int* totalBits: pointer to callers' area to receive size of returned int array
Returns:
int* a pointer to a malloc'd array that contains the extracted bits from 'value'
 least significant bit at offset 0 into the array.
 note: the caller must 'free()' this array when done using it 


#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;

#define TOTAL_BITS (sizeof(int)&lt;&lt;3) // assumes 8 bit bytes
#define BIT_MASK(count) (1&lt;&lt;count)

int * extractAllBitsFromIntToArray( int value, int* numBits)
{
 int i = 0; // loop counter
 int *pRetArray = NULL;
 if( NULL == (pRetArray = malloc( TOTAL_BITS*sizeof(int)) ) ) // array to return
 {
 perror( "malloc failed" );
 exit( EXIT_FAILURE );
 }

 memset( pRetArray, 0x00, TOTAL_BITS*sizeof(int) ); // clear array

 // extract bits, where pRetArray[0] is LSB
 for( i=0; i&lt;TOTAL_BITS; i++ )
 {
 pRetArray[i] = (value&amp;(BIT_MASK(i)))? 1:
 }

 return( pRetArray );
} // end function: extractAllBitsFromIntToArray
</code></pre>

I have a problem of extracting the last 4 numbers of a binary representation
My number is: <code>1111 1001</code>
I got the first <code>4</code>
However I have the problem to got the last four^:

<pre><code> # include &lt;stdio.h&gt;
 # include &lt;stdlib.h&gt;
 # define BYTETOBINARYPATTERN "%d%d%d%d%d%d%d%d\n"
 # define BYTETOBINARY(byte) \
 (byte &amp; 0x80 ? 1 : 0), \
 (byte &amp; 0x40 ? 1 : 0), \
 (byte &amp; 0x20 ? 1 : 0), \
 (byte &amp; 0x10 ? 1 : 0), \
 (byte &amp; 0x08 ? 1 : 0), \
 (byte &amp; 0x04 ? 1 : 0), \
 (byte &amp; 0x02 ? 1 : 0), \
 (byte &amp; 0x01 ? 1 : 0) 

 int main()
 {
 int num = 505;
 PRINTBIN (num);

 // int result = num &amp; bitwise;
 //PRINTBIN(result);
 // first num;
 int i;
 int bit=0x01;
 int bitwise;
 for (i =0;i&lt;4;i++)
 {
 int bit1=bit&lt;&lt;i;
 bitwise = bit1|bit;

 }
 printf("1:%d\n", bitwise);
 PRINTBIN(bitwise);

 //second num;
 int bitwise1;
 int b0 = 0;
 int bit2;
 for(i=0;i&lt;4;i++)
 {
 bit2 = bit&lt;&lt;(4+i);
 bitwise1 = bit2|b0; 
 PRINTBIN(bit2);
 }
 printf("2:%d\n",bitwise1);
 PRINTBIN(bitwise1);

 return 0;

}
</code></pre>

Extracting the last four digit of an int 's binary representation

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我在提取二进制表示的最后4个数字时遇到了问题，我的数字是：，我得到了第一个4，但是我得到了最后四个^： # include <stdio.h> # include <stdlib.h> # define BYTETOBINARYPATTERN "%d%d%d%d%d%d%d%d\n" # define BYTETOBI...

问提取整型二进制表示的最后四位数
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问提取整型二进制表示的最后四位数EN