C++ 在C+中显示浮点类型的二进制表示+；

对于整型，请考虑以下代码：

template <class T>
std::string as_binary_string( T value ) {
    return std::bitset<sizeof( T ) * 8>( value ).to_string();
}

int main() {
    unsigned char a(2);
    char          b(4);

    unsigned short c(2);
    short          d(4);

    unsigned int   e(2);
    int            f(4);

    unsigned long long g(2);
    long long h(4);

    std::cout << "a = " << +a << " " << as_binary_string( a ) << std::endl;
    std::cout << "b = " << +b << " " << as_binary_string( b ) << std::endl;
    std::cout << "c = " << c << " " << as_binary_string( c ) << std::endl;
    std::cout << "d = " << c << " " << as_binary_string( d ) << std::endl;
    std::cout << "e = " << e << " " << as_binary_string( e ) << std::endl;
    std::cout << "f = " << f << " " << as_binary_string( f ) << std::endl;
    std::cout << "g = " << g << " " << as_binary_string( g ) << std::endl;
    std::cout << "h = " << h << " " << as_binary_string( h ) << std::endl;

    std::cout << "\nPress any key and enter to quit.\n";
    char q;
    std::cin >> q;

    return 0;
}

模板
std:：字符串作为二进制字符串（T值）{
返回std:：bitset（value）.to_string（）；
}
int main（）{
无符号字符a（2）；
字符b（4）；
无符号短c（2）；
短d（4）；
无符号整数e（2）；
INTF（4）；
无符号长g（2）；
长h（4）；
自己写一本怎么样

static_assert(sizeof(float) == sizeof(uint32_t));
static_assert(sizeof(double) == sizeof(uint64_t));

std::string as_binary_string( float value ) {
    std::uint32_t t;
    std::memcpy(&t, &value, sizeof(value));
    return std::bitset<sizeof(float) * 8>(t).to_string();
}

std::string as_binary_string( double value ) {
    std::uint64_t t;
    std::memcpy(&t, &value, sizeof(value));
    return std::bitset<sizeof(double) * 8>(t).to_string();
}

你说它不需要是标准的。所以，下面是在我的电脑上叮当作响的工作原理：

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
  char *result;
  result=new char[33];
  fill(result,result+32,'0');
  float input;
  cin >>input;
  asm(
"mov %0,%%eax\n"
"mov %1,%%rbx\n"
".intel_syntax\n"
"mov rcx,20h\n"
"loop_begin:\n"
"shr eax\n"
"jnc loop_end\n"
"inc byte ptr [rbx+rcx-1]\n"
"loop_end:\n"
"loop loop_begin\n"
".att_syntax\n"
      :
      : "m" (input), "m" (result)
      );
  cout <<result <<endl;
  delete[] result;
  return 0;
}

#包括
#包括
使用名称空间std；
int main（）
{
字符*结果；
结果=新字符[33]；
填充（结果，结果+32，'0'）；
浮点输入；
cin>>输入；
asm(
mov%0，%%eax\n
mov%1，%%rbx\n
“.intel\u语法\n”
mov rcx，20小时\n
“循环\u开始：\n”
“shr eax\n”
“jnc循环\u结束\n”
“inc字节ptr[rbx+rcx-1]\n”
“循环\u结束：\n”
“循环\u开始\n”
“.att_语法\n”
:
：“m”（输入），“m”（结果）
);
coutIEEE浮点数如下所示

sign  exponent   mantissa
1 bit  11 bits    52 bits 

注意尾数和指数前有一个隐藏的1
是有偏差的，所以1023=0，而不是2的补码。
通过对64位无符号整数进行memcpy（）运算，可以应用
或掩模以获得位模式。排列可以是大端
或是小恩迪安。
通过传递简单的数字，您可以很容易地计算出您的排列方式
例如1或2。
您可以通过将float/double的地址强制转换为一个字符并以这种方式进行迭代来滚动：

#include <memory>
#include <iostream>
#include <limits>
#include <iomanip>

template <typename T>
std::string getBits(T t) {
    std::string returnString{""};
    char *base{reinterpret_cast<char *>(std::addressof(t))};
    char *tail{base + sizeof(t) - 1};
    do {
        for (int bits = std::numeric_limits<unsigned char>::digits - 1; bits >= 0; bits--) {
            returnString += ( ((*tail) & (1 << bits)) ? '1' : '0');
        }
    } while (--tail >= base);
    return returnString;
}

int main() {
    float f{10.0};
    double d{100.0};
    double nd{-100.0};
    std::cout << std::setprecision(1);
    std::cout << getBits(f) << std::endl;
    std::cout << getBits(d) << std::endl;
    std::cout << getBits(nd) << std::endl;
}

一般人们都使用<代码> STD:：HxFooS或者将指针指向浮点值，将指针指向相同大小的无符号整数，并以十六进制格式打印间接值。两种方法以一种有效率的方式促进浮点的位级分析。都不是我所知道的。@user0042-hmm我必须求助于“C”风格的编码吗？我不知道你说的“C”到底是什么意思风格编码，但我认为显示浮点值的位表示有点超出C++标准，正如你在你的问题中提到的那样。双精度是一个合适的整数类型。字节数是指字节是如何存储在内存中的，而不是值。<代码> x和1 < /COD>总是给你最低的比特，而不是AffEC。我确信OP已经想到了类似的东西。
static\u assert（sizeof（float）==sizeof（uint32\t））
是造成这种情况的原因。嗯，我从来没有想过要转换到
uint32\u t
&
uint64\u t
…但是不同的EDIAN和编码会影响这一点吗？但是，是的，我同意user0042想要更通用的东西。我对
位操作
或
位旋转不感兴趣
。我只想要一个可视化表示，并且喜欢为任何
基本算术类型设置模板。但是，如果需要进行位操作，这个类模板可以将
二进制
表示以字符串的形式发送给用户。@FrancisCugler当然可以。请稍候，我正在更新我的答案。@FrancisCugler标准仅定义了无符号整数值的可调表示。未定义有符号整数值的表示（因实现而异），甚至不是浮点数。是的；我已经阅读了有关IEEE标准的文章、文档和白皮书……实际上有两个版本。但是，指数和尾数的位数将根据浮点类型的大小而变化，通过
float
、
double
或
long double*
提供编译器-操作系统支持长双精度
，以及其他一些因素。“您说过它不需要是标准的”。OP没有这样说。OP说您不必使用标准库。
#include <memory>
#include <iostream>
#include <limits>
#include <iomanip>

template <typename T>
std::string getBits(T t) {
    std::string returnString{""};
    char *base{reinterpret_cast<char *>(std::addressof(t))};
    char *tail{base + sizeof(t) - 1};
    do {
        for (int bits = std::numeric_limits<unsigned char>::digits - 1; bits >= 0; bits--) {
            returnString += ( ((*tail) & (1 << bits)) ? '1' : '0');
        }
    } while (--tail >= base);
    return returnString;
}

int main() {
    float f{10.0};
    double d{100.0};
    double nd{-100.0};
    std::cout << std::setprecision(1);
    std::cout << getBits(f) << std::endl;
    std::cout << getBits(d) << std::endl;
    std::cout << getBits(nd) << std::endl;
}

01000001001000000000000000000000
0100000001011001000000000000000000000000000000000000000000000000
1100000001011001000000000000000000000000000000000000000000000000