简言之,你没有。

双向操作者在应用到<条码>时并不具有意义。

。 假设你可以改变<条码>杜布尔的权利。 具体说来,意思是,没有简单的翻译,无法改变借方模式的权利——签字权将变成权宜之计,而最不重要的权宜之计将转变为权人,其含义完全不相干。 在ISO 754中,在实际红利线前有隐含的1轨,这也使解释复杂化。

类似的评论适用于其他任何仲裁员。

因此,由于对轨道操作者没有打字或有用的解释,因此标准不允许使用。

评论:

我只关心双位代表。 我只想印刷它,而没有做任何有益的事。

几年前,该法典是为南太平洋研究中心(大公国)结构撰写的。

#include <stdio.h>

union u_double
{
    double  dbl;
    char    data[sizeof(double)];
};

union u_float
{
    float   flt;
    char    data[sizeof(float)];
};

static void dump_float(union u_float f)
{
    int exp;
    long mant;

    printf("32-bit float: sign: %d, ", (f.data[0] & 0x80) >> 7);
    exp = ((f.data[0] & 0x7F) << 1) | ((f.data[1] & 0x80) >> 7);
    printf("expt: %4d (unbiassed %5d), ", exp, exp - 127);
    mant = ((((f.data[1] & 0x7F) << 8) | (f.data[2] & 0xFF)) << 8) | (f.data[3] & 0xFF);
    printf("mant: %16ld (0x%06lX)
", mant, mant);
}

static void dump_double(union u_double d)
{
    int exp;
    long long mant;

    printf("64-bit float: sign: %d, ", (d.data[0] & 0x80) >> 7);
    exp = ((d.data[0] & 0x7F) << 4) | ((d.data[1] & 0xF0) >> 4);
    printf("expt: %4d (unbiassed %5d), ", exp, exp - 1023);
    mant = ((((d.data[1] & 0x0F) << 8) | (d.data[2] & 0xFF)) << 8) | (d.data[3] & 0xFF);
    mant = (mant << 32) | ((((((d.data[4] & 0xFF) << 8) | (d.data[5] & 0xFF)) << 8) | (d.data[6] & 0xFF)) << 8) | (d.data[7] & 0xFF);
    printf("mant: %16lld (0x%013llX)
", mant, mant);
}

static void print_value(double v)
{
    union u_double d;
    union u_float  f;

    f.flt = v;
    d.dbl = v;

    printf("SPARC: float/double of %g
", v);
//    image_print(stdout, 0, f.data, sizeof(f.data));
//    image_print(stdout, 0, d.data, sizeof(d.data));
    dump_float(f);
    dump_double(d);
}


int main(void)
{
    print_value(+1.0);
    print_value(+2.0);
    print_value(+3.0);
    print_value( 0.0);
    print_value(-3.0);
    print_value(+3.1415926535897932);
    print_value(+1e126);
    return(0);
}

评论的图像是:印刷功能印刷了一套带有各种微薄的黑体的任意 by。 如果你想要守则,与我联系(见我的简介)。

如果你重新使用英特尔(航天飞机端人),你很可能需要打碎该代码,以处理倒转轨命令。 但是,它表明你如何使用<代码>union。

您不能直接将双向操作员应用到<代码>float或double上,但你仍可以通过将变数列入一个<代码>union<>/code>,并具有适当规模的特性阵容,然后阅读这些字节。 例如:

string BitsFromDouble(double value) {
    union {
        double doubleValue;
        char   asChars[sizeof(double)];
    };

    doubleValue = value; // Write to the union

    /* Extract the bits. */
    string result;
    for (size i = 0; i < sizeof(double); ++i)
        result += CharToBits(asChars[i]);
    return result;
}

你也许需要调整例行工作,处理通常不超过4096年的果园,在这里,可能有一些杂乱,但基本想法应当发挥作用。 由于机器使用不同的终端和双倍的代表性,因此它赢得的双向兼容,因此,你如何使用。

Biwise的操作者一般不从事“组合代表”的工作(也称<>目标代表)任何类型。 比维兹公司与这种类型的价值代表<>/em>合作,后者通常不同于标语代表。 本条适用于<代码>int。 以及<代码>2()。

If you really want to get to the internal binary representation of an object of any type, as you stated in your question, you need to reinterpret the object of that type as an array of unsigned char objects and then use the bitwise operators on these unsigned chars

例如

double d = 12.34;
const unsigned char *c = reinterpret_cast<unsigned char *>(&d);

现在,通过查阅<条码>c[0],通过<条码>c[(双重)- 1>,请见<条码>的内分。 如果你想要的话,你可以使用<条码>未经签名的数值上的双向操作。

请注意,一般来说,为了获得<代码>>>t的内部代表,你必须做同样的事情。 它一般适用于 任何。 除<代码>之外的其他类型:

Do a bit-wise cast of a pointer to the double to long long * and dereference. Example:

inline double bit_and_d(double* d, long long mask) {
  long long t = (*(long long*)d) & mask;
  return *(double*)&t;
}

Edit:这几乎肯定会波及执行严格割礼。 为此利用各种工作。 (memcpy, unions, _attribute__(__may_alias__), 等)

另一种解决办法是找到浮动点变数的点子,将其放在同一面积的分类点上,然后获得该点点点点点值。 现在,你有象浮动点一一样的虚构,可以使用你的双向操作员。

string findBin(float f) {
    string binary;
    for(long i = 4096 ; i >= 1; i/=2) {
        long x = * ( long * ) &y;
        if((x & i) != 0) binary += "1";
        else binary += "0";
    }
    return binary;
}

但记住:你必须投向面积相同的一类。 否则,可能发生无法预测的事件(如缓冲溢出、侵犯通行等)。

正如其他人所说的那样,你可以采用双向操作器,将<条码>杜布尔*投到<条码>长期*<>。 (或有时只是long*)。

int main(){
    double * x = (double*)malloc(sizeof(double));
    *x = -5.12345;
    printf("%f
", *x);
    *((long*)x) &= 0x7FFFFFFFFFFFFFFF;
    printf("%f
", *x);
    return 0;
}

在我的电脑上,该代码打印如下:

-5.123450
5.123450