输出无符号短路C的位值

问题描述

我有一个函数，它带有一个无符号的short并显示它的位值。当前，它显示除前0之外的所有数字，而我想显示所有16位位置。

void display_result(unsigned short result)
{
     if(result >> 1)
     {
          display_result(result >> 1);
     }
     if(result & 1)
     {
          putc('1',stdout);
     }
     else
     {
          putc('0',stdout);
     }
     return;
}

示例输入：3
所需的输出：0000000000000011
实际输出：11

我对代码的理解是，它本质上是按照结果通过数组的方式遍历结果的位值，并基于if语句输出，但这实际上并没有发生，这表明我遗漏了什么。有人可以对此有所启发吗？ （注意：发布前我已经搜索了此信息，但可能缺少搜索功能）。

解决方法

您需要完整的16次迭代，而不仅仅是直到没有有效数字为止。 使用您的方法，您可以添加一个depth参数：

#include <stdio.h>
#include <limits.h>
    static void display_result_n_(unsigned short result,int n)
    {
         if(--n) { display_result_n_(result>>1,n); }
         if(result & 1) { putc('1',stdout); }
         else { putc('0',stdout); }
         return;
    }

void display_result(unsigned short result)
{
    display_result_n_(result,sizeof(unsigned short)*CHAR_BIT);
}
int main()
{
    display_result(3);
    puts("");
}

或者您可以迭代地进行。对于两个基数的基数，不需要还原 （通过递归为您完成），如果您只是简单地从另一（最重要）方面进行测试 滑动1<<15遮罩16次。

void display_result(unsigned short result)
{
    unsigned mask = 1U<<((sizeof(unsigned short))*CHAR_BIT-1);
    for(;mask;mask>>=1) putc('0'+ !!(result&mask),stdout );
}

,

递归函数需要知道必须递归调用多少次。那就是需要某种方式来知道unsigned short类型的对象的大小。

通常有两种方法。

第一个是两个编写两个函数。第一个具有至少一个参数，即数字，第二个具有至少两个参数，即数字和当前位位置。

这是一个演示程序。

HTTPError                                 Traceback (most recent call last)
<ipython-input-5-b158a1e893a0> in <module>
----> 1 html = urlopen("https://dblp.org/db").read()
      2 #print(html)
      3 soup = BeautifulSoup(html)
      4 soup.prettify()

~\Anaconda3\lib\urllib\request.py in urlopen(url,data,timeout,cafile,capath,cadefault,context)
    220     else:
    221         opener = _opener
--> 222     return opener.open(url,timeout)
    223 
    224 def install_opener(opener):

~\Anaconda3\lib\urllib\request.py in open(self,fullurl,timeout)
    529         for processor in self.process_response.get(protocol,[]):
    530             meth = getattr(processor,meth_name)
--> 531             response = meth(req,response)
    532 
    533         return response

~\Anaconda3\lib\urllib\request.py in http_response(self,request,response)
    639         if not (200 <= code < 300):
    640             response = self.parent.error(
--> 641                 'http',response,code,msg,hdrs)
    642 
    643         return response

~\Anaconda3\lib\urllib\request.py in error(self,proto,*args)
    567         if http_err:
    568             args = (dict,'default','http_error_default') + orig_args
--> 569             return self._call_chain(*args)
    570 
    571 # XXX probably also want an abstract factory that knows when it makes

~\Anaconda3\lib\urllib\request.py in _call_chain(self,chain,kind,meth_name,*args)
    501         for handler in handlers:
    502             func = getattr(handler,meth_name)
--> 503             result = func(*args)
    504             if result is not None:
    505                 return result

~\Anaconda3\lib\urllib\request.py in http_error_default(self,req,fp,hdrs)
    647 class HTTPDefaultErrorHandler(BaseHandler):
    648     def http_error_default(self,hdrs):
--> 649         raise HTTPError(req.full_url,hdrs,fp)
    650 
    651 class HTTPRedirectHandler(BaseHandler):

HTTPError: HTTP Error 406: Not Acceptable

程序输出为

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

FILE * display_result( unsigned short n,size_t size,FILE *fp )
{
    if ( size != 0 )
    {
        display_result( n >> 1,size - 1,fp );
        fputc( ( n & 1 ) + '0',fp );
    }
    
    return fp;
}

FILE * bit_image( unsigned short n,FILE *fp )
{
    display_result( n,sizeof( unsigned short ) * CHAR_BIT,fp );
    
    return fp;
}

int main(void) 
{
    for ( unsigned short i = 0; i < 16; i++ )
    {
        fputc( '\n',bit_image( i,stdout ) );
    }
    
    return 0;
}

第二种方法是拥有一个静态局部变量，该变量将对递归调用进行计数。

例如

0000000000000000
0000000000000001
0000000000000010
0000000000000011
0000000000000100
0000000000000101
0000000000000110
0000000000000111
0000000000001000
0000000000001001
0000000000001010
0000000000001011
0000000000001100
0000000000001101
0000000000001110
0000000000001111

程序输出与上面显示的相同。