精华内容
下载资源
问答
  • 二进制变量举例
    2021-02-25 18:11:35

    1. 变量

    1. 他 她 我 你 某人 佚名 旺财 X-man x = 1

    您好! 它

    (变量就是自然语言中的代词)

    2. int age = 15;// 00000000 00000000 00000000 00001111

    3. Java 中的变量

    a Java是强类型语言,

    b 变量必须声明,并且初始化以后使用

    c 变量必须有明确的类型

    d 变量不能重复定义

    4. 变量的作用域

    a 在声明的地方开始,到块结束为止

    b 离开变量的作用域结束,变量将回收。

    2. 二进制

    1. 计算机内部只有二进制数据!

    int i = 15; char c = 'A';

    'A'-> 00000000 01000001

    15 -> 00000000 00000000 00000000 00001111

    115 = 1*100 + 1*10 + 5*1

    = 1×10^2 + 1×10^1 + 5×10^0

    基数: 10

    权: 基数^n

    基数:2

    权:  128 64 32 16 8 4 2 1

    2. 二进制: 1111= 1*2^3+1*2^2+ 1*2^1 + 1*2^0

    = 1*8 + 1*4 + 1*2 + 1*1

    = 15(10)

    8421

    1001 = 9

    01000001 = 1*64 + 1*1

    = 65(10)

    128 64 32 16 8 4 2 1

    1   1   0   0  0 0 0 0 = 192(10)

    3. 十进制:  65 = 6*10 + 5*1

    = 6*10^1 + 5*10^0

    256 128 64 32 16 8 4 2 1

    95(10)=   0  1   0  1 1 1 1 1 (2)

    int age = 15;

    age = 00000000 00000000 00000000 00001111

    int age = 0xf;

    4. 16进制

    0 1 2 3 4 5 6 7 8 9 a  b   c   d   e   f

    10 11 12 13 14 15

    41(16) = 4 * 16 +1 = 65(10)

    4    1

    0100 0001(2) = 65(10)

    * 将16进制作为2进制的简写形式.

    4e2d(16)=0100 1110 0010 1101(2)

    5. 八进制是二进制的简写,3位对应转换

    3.原码、补码、反码

    1、原码:一个正数,按照绝对值大小转换成的二进制数;一个负数按照绝对值大小转换成的二进制数,然后最高位补1,称为原码。

    比如 00000000 00000000 00000000 00000101 是 5的 原码。

    10000000 00000000 00000000 00000101 是 -5的 原码。

    备注:

    比如byte类型,用2^8来表示无符号整数的话,是0 - 255了;

    如果有符号, 最高位表示符号,0为正,1为负,那么,正常的理解就是 -127 至 +127 了.这就是原码了,

    值得一提的是,原码的弱点,有2个0,即+0和-0(10000000和00000000);

    还有就是,进行异号相加或同号相减时,比较笨蛋,先要判断2个数的绝对值大小,然后进行加减操作,最后运算结果的符号还要与大的符号相同;

    于是,反码产生了。

    2、    反码:正数的反码与原码相同,负数的反码为对该数的原码除符号位外各位取反[每一位取反(除符号位)]。

    取反操作指:原为1,得0;原为0,得1。(1变0; 0变1)

    比如:正数00000000 00000000 00000000 00000101  的反码还是 00000000 00000000 00000000 00000101

    负数10000000 00000000 00000000 00000101  的反码则是 11111111 11111111 11111111 11111010。

    反码是相互的,所以也可称:10000000 00000000 00000000 00000101 和 11111111 11111111 11111111 11111010互为反码。

    备注:还是有+0和-0,没过多久,反码就成为了过滤产物,也就是,后来补码出现了。

    3、 补码:正数的补码与原码相同,负数的补码为对该数的原码除符号位外各位取反,然后在最后一位加1.

    比如:10000000 00000000 00000000 00000101 的反码是:11111111 11111111 11111111 11111010。

    那么,补码为:

    11111111 11111111 11111111 11111010 + 1 = 11111111 11111111 11111111 11111011

    备注:1、从补码求原码的方法跟原码求补码是一样的 ,也可以通过完全逆运算来做,先减一,再取反。

    2、补码却规定0没有正负之分

    所以,-5 在计算机中表达为:11111111 11111111 11111111 11111011。转换为十六进制:0xFFFFFFFB。

    举例:

    a. -2*2 = -4

    -2  1110

    X  2  0010

    ---------------

    0000

    1110

    0000

    +   0000

    ----------------

    -4   1100

    b. -2 + 3 = 1

    -2  1110

    +   3  0011

    111

    -----------------

    1 0001

    c. -1+-1 = ?

    -1   1111

    -1   1111

    +        1111

    -------------------

    -2   1110

    d. 7+1 = ?

    7   0111

    +   1   0001

    -----------------

    -8   1000

    e.~3 + 1 = ?

    3   0011

    ~3   1100

    +1   0001

    ------------

    -3   1101

    -3   1101

    ~-3  0010

    +1   0001

    -------------

    3   0011

    强调:补码运算时负号只与第一位数相连,然后再与后面的数进行运算,如上例-1+-1(1110为-2的补码),~3 + 1(1101为-3的补码)

    总结:

    正数的反码和补码都与原码相同。

    负数的反码为对该数的原码除符号位外各位取反。

    负数的补码为对该数的原码除符号位外各位取反,然后在最后一位加1

    源码:优点在于换算简单 缺点在于两个零 加减法需要独立运算

    反码:有点在于表示清晰 缺点在于两个零 加减法同样需要独立运算

    补码:优点在于一个零 范围大  减法可以转为加法 缺点在于理解困难

    4.Java的数据类型

    1. Java数据分为基本类型和引用类型. Person someone

    2. 基本类型分为八种:

    byte short int long float double char boolean

    (a) 整数类型 byte short int long

    整数都是有符号整数

    byte   8bit  -128 ~ +127

    short 16bit  -32768 ~ 32767

    int   32bit  -2G ~ 2G-1  -2^31 ~ 2^31-1

    long  64bit  -2^63 ~ 2^63-1

    int a = 5;

    建议使用int, 很少使用short,使用int要注意取值范围, int 的值不大!

    直接量-字面量: 直接给出的常量值如: 1

    a. 整数的直接量的类型默认是int类型

    b. 以L,l为结尾的字面量是long类型

    1024

    1024L

    c. 可以使用整数直接量给byte,short类型赋值,但是不要超过byte和short的范围.

    (b) 浮点数: 就是小数, float, double

    34642323.44 = 3.464232344 * 10^7

    尾数              指数

    10001000.(2)

    1.0001000 * 2^111(2)

    尾数            指数

    float 32位

    0     00000111 10001000000000000000000

    符号位 指数       尾数

    int a = 0x7fffffff;

    float f = a;

    double

    1 符号位

    11 指数

    52 尾数

    a. double 是64位, float 32位

    double比float精确

    b. 默认的浮点数字面量是: double类型的

    字面量后缀: d/D f/F

    double d = 1d;//1.0

    1 1L 1D 1F

    c. 只使用double计算浮点数,float类型基本不用!

    浮点数不能精确运算

    int:10001000 -> float:1.0001000*2^111

    0 00000111 10001000 00000000 0000000

    (c) 字符类型:char, 字符类型是一个16位无符号整数!

    a. 字符类型的值是对应字符的编码, 是unicode编码. Java支持国际化.

    英文部分的值与ascII编码一致.

    char是定长编码, 所有的字符都是16位.

    'A' -> 0x0041

    '中'-> 0x4e2d

    在编码中: '0'~'9' , 'a'~'z', 'A'~'Z'都是连续编码的!

    '0'=='\u0000'  '\u0000'==0

    b. 最小值:0, 最大值:65535 = 2^16-1

    c. 字符字面量使用单引号为定界符号:'中'

    字面量也是整数常量!

    特殊字符采用转义字符表示:

    如: '\n' '\t' '\\' '\b' '\r'

    '\'' '\"'  '\u4e2d'

    char c = '\\';

    (d)布尔类型: boolean

    字面量: true false

    float f = (float)2.6D;

    char c = 65;

    5.数据类型转换:

    1. 自动类型转换(隐式类型转换)

    从小类型到大类型, 自动完成

    如: int n = 'A';

    long l = 'A';

    char-------->int------>long------->float------>double

    byte------->short------->int------>long------->float------>double

    2. 强制类型转换, 从大类型到小类型需要强制转换

    强制类型转换有风险, 会造成精度损失或者溢出

    char

    byte

    long l = 1024L*1024*1024*4;//0x100000000

    int i = (int)l;//0

    double pi = 3.1415926535897932384626;

    float f = (float)pi;

    若有不完善的地方请大家多提意见,转发时请注明出处!

    更多相关内容
  • 十进制转二进制

    2022-05-29 20:47:14
    十进制转二进制的思路与实现。

    最近在看Java jdk的源码,源码里会用到许多二进制的运算,因此会使用到十进制转二进制的工具。心血来潮想自己实现一个简单的转换工具,心动不如行动,let'go !

    温馨提示:文中的代码实现并未考虑性能以及内存消耗,仅跟着思路随手写下,并伴有少许拼音变量名。

    正的十进制转二进制比较简单,首先理清楚手算十进制时的过程(原谅我是个灵魂画手):

     从这个计算过程得出:输入的正数除以2,依次记录余数,最终把余数按照倒序(从下往上)拼接在一起即得到结果,5(十进制)=101(二进制)。代码实现:

    import java.util.Stack;
    
    public class CalService {
    
        private Stack stack = new Stack();
    
        /**
         * 十进制转二进制
         *
         * @param tenNum 十进制数
         * @return 转换的二进制结果
         */
        public String ten2Two(Integer tenNum) {
            StringBuilder sb = new StringBuilder();
                cal(tenNum);
                //输出栈的所有内容得到结果
                while (!stack.empty()) {
                    sb.append(stack.pop().toString());
                }
        }
    
        private void cal(Integer tenNum) {
            //除2取商
            Integer quotient = tenNum / 2;
            //除2取余,把余数放入栈中
            stack.push(tenNum % 2);
            //如果余数大于1继续计算,否则计算结束
            if (quotient > 1) {
                //递归计算
                cal(quotient);
            } else {
                stack.push(quotient);
                return;
            }
        }
    }

    PS:由于最后需要把余数按照倒序进行拼接,即先入后出,第一个想到的就是使用栈来存放。

    负的十进制转二进制会相对复杂一些,概括起来就是其原码的补码。以 -5 来举例:

    第一步:计算该负数绝对值的二进制,也就是其正数的原码:

    5的原码      101

    第二步:int值最多为32位,最高位用于表示正负,正为0,负为1。因此把101的最高位置1,其余位补0,得到负数的原码

    -5的原码    10000000 00000000 00000000 00000101

    第三步:计算负数原码的反码。正数的反码与原码相同,负数的反码为原码除符号位(最高位的1)外,其余取反

    -5的反码    11111111 11111111 11111111 11111010

    第四步:计算负数原码的补码。正数的补码与原码相同,负数的补码为反码加1(这也是为什么我们要先算其反码)。

    -5的补码    11111111 11111111 11111111 11111011

    最终得到-5(十进制)=11111111 11111111 11111111 11111011(二进制)。

    上述过程中,蓝色内容就是需要实现的代码逻辑,代码如下:

    import java.util.Stack;
    
    /**
     * 十进制转二进制,正、负数均可
     */
    public class CalService {
    
        private Stack stack = new Stack();
    
        /**
         * 十进制转二进制
         *
         * @param tenNum 十进制数
         * @return 转换的二进制结果
         */
        public String ten2Two(Integer tenNum) {
            StringBuilder sb = new StringBuilder();
            //正数转二进制
            if (tenNum > 0) {
                cal(tenNum);
                while (!stack.empty()) {
                    sb.append(stack.pop().toString());
                }
                return sb.toString();
            } else {//负数转二进制
                //计算该负数绝对值的二进制
                tenNum = -tenNum;
                cal(tenNum);
                //判断需要补0的个数
                int buZeroCount = 31 - stack.size();
                //最高位置1,其余位补0,得到负数的原码
                StringBuilder newSb = new StringBuilder();
                newSb.append("1");
                //int最多32位,空的位置补0,加上最高位为1表示负数,补满32位
                for (int i = 0; i < buZeroCount; i++) {
                    newSb.append("0");
                }
                while (!stack.empty()) {
                    newSb.append(stack.pop().toString());
                }
                //计算反码,原码除符号位(最高位的1)外,其余取反
                String[] bits = newSb.toString().split("");
                for (int i = 1; i < 32; i++) {
                    String bit = bits[i];
                    if (bit.equals("0")) bits[i] = "1";
                    else bits[i] = "0";
                }
                //反码加1
                for (int i = 31; i > 0; i--) {
                    String bit = bits[i];
                    if (bit.equals("0")) {
                        bits[i] = "1";
                        break;
                    } else {
                        bits[i] = "0";
                    }
                }
                StringBuilder resultSb = new StringBuilder();
                //输出结果
                for (int i = 0; i < 32; i++) {
                    resultSb.append(bits[i]);
                }
                return resultSb.toString();
            }
        }
    
        private void cal(Integer tenNum) {
            Integer quotient = tenNum / 2;
            stack.push(tenNum % 2);
            if (quotient > 1) {
                cal(quotient);
            } else {
                stack.push(quotient);
                return;
            }
        }
    }
    

    为了方便测试,再写一个main方法作为入口:

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class main {
        public static void main(String[] arg) throws IOException {
            System.out.print("请输入要转换为二进制的十进制数:");
            CalService calService = new CalService();
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(calService.ten2Two(Integer.valueOf(line)));
                System.out.print("请输入要转换为二进制的十进制数:");
            }
        }
    }

    输出:

     

    展开全文
  • 计算机二进制储存

    千次阅读 2018-10-09 01:26:37
    计算机二进制储存 我们都知道,计算机储存数据最终都是转换成二进制数字进行储存,而计算机进行简单的运算时,也是通过二进制下的数字进行计算的,下面我们就探究一下计算机在二进制储存下的计算方式。 首先我们在...

    计算机二进制储存

    我们都知道,计算机储存数据最终都是转换成二进制数字进行储存,而计算机进行简单的运算时,也是通过二进制下的数字进行计算的,下面我们就探究一下计算机在二进制储存下的计算方式。

    首先我们在数学中学习过对一个十进制数字进行除二取余法之后倒序排列获得这个十进制数的二进制数。以(11)_{10}为例:

    11除以2等于5,余数为1;5除以2等于2,余数为1;2除以2等于1,余数为0;1除以2等于0,余数为1。最后我们得到了1101,倒序排列就是1011,这就是二进制数的11,即(11)_{10}=(1011)_2

    在计算机中,一个整数通常存放在一个整数型变量中,对于java而言,其整数型变量类型有byte, short, int, long四种;对于c++而言,其整型有unsigned int, int, long int(这里声明一点,c++语言中有short, int, long int, long long, long long int等等整型的数据类型,但是这些类型有微妙的关系。这和c语言当时的定义有关,c语言定义整型数据的空间占用根据操作系统的位数,具体大家可以参考其他博客资料或者书籍资料。而c语言标准也有这么一句话:长整型至少和整型一样长,整型至少和短整型一样长。也就是说int可以和short一样长,long可以和int一样长。这里我只列出三个类型,分别占用4Bytes, 4Bytes, 8Bytes)。

    计算机储存变量的时候,通常把最左边一位当做符号位,即0表示正数,1表示负数。比如4Bytes的int类型变量储存了十进制的11,那么在内存中它的存在形式是00000000 00000000 00000000 00001011,那么如果它储存的是十进制的-11,那么它的存在形式是10000000 00000000 00000000 00001011,这个数就叫二进制原码。

    但是当我们以二进制原码进行计算的时候,就会有出乎意料的问题发生,我把二进制下的11和-11相加(我按照1Byte长度的数字进行演示,这样省略了中间很多的0,看起来很方便),就是00001011 + 10001011 = 10010110 = (-22)_{10},这不正确!!!我们期望的结果是0,但是真正的计算结果是-22,发生了什么?!

    这就要引出我们对于反码的概念,我们看到了对二进制原码进行计算会发生出乎预料的结果。所以数学家们很聪明,他们设计了一种二进制编码叫做反码。其规范是这个样子,对于一个正数,其二进制反码和原码相同;对于一个负数,其二进制反码即其二进制原码除了符号位各位取反后的结果。拿13和-15举例:(注明一下,因为我的原稿用的是原,反,补三个字做下标的。但是CSDN的公式不能使用中文作为下标,因此我就取这三个字的拼音首字母作为下标,请各位注意)(13)_{10}=(00001101)_y=(00001101)_f(-15)_{10}=(10001111)_y=(11110000)_f。那么13 + (-15) = (00001101)_f + (11110000)_f = (11111101)_f = (10000010)_y = (-2)_{10}。那么我们再拿15 + (-13)举例:15 + (-13) = (00001111)_f + (11110010)_f = (1\ 00000001)_f这里发生了进位,怎么办?别担心,二进制反码的计算准则是若存在进位,则把进位放到末尾位加上,简单来说就是把多出来的1加给后面的00000001,结果就是(00000010)_f=(+2)_{10}。是不是超级神奇?

    但是即便是反码运算,也会存在 (00000000)_f(11111111)_f这两个东西,你可以把它转化成原码看。妈耶!这两个一个是+0一个是-0,而它俩竟然不是一个东西。我学过的数学0就是0,不存在-0这种东西耶?

    所以这就引出了下一个东西,它叫做补码。补码的定义和反码很像,对于一个正数,它的二进制补码是它的二进制原码;对于一个负数,它的二进制补码是它的二进制反码再加上1。

    还是拿-11举例子:(-11)_{10}=(10001011)_y=(11110100)_f=(11110101)_b。接下来还是拿15+(-13)和13+(-15)进行举例:13 + (-15) = (00001101)_b + (11110001)_b = (11111110)_b = (11111101)_f = (10000010)_y = (-2)_{10}15 + (-13) = (00001111)_b + (11110011)_b = (1\ 00000010)_b。这里要注意了,补码的计算和反码不一样,如果多出了1,那么直接当做越界处理,简单来说就是直接扔掉,保留之后的就好。也就是说,这里的(1\ 00000010)_b = (00000010)_b = (00000010)_y = (+2)_{10}。这样一来补码的计算问题也就解决了,那么接下来就是所谓的+0和-0的问题了,对于(-0)_{10} = (10000000)_y = (11111111)_f = (1\ 00000000)_b,我们不难发现,补码的-0直接越界了,按照我们之前的处理,1被扔掉了,那么又剩下00000000即+0了。我们统一了+0和-0!这很完美!

    但是我们还是发现了有一个二进制补码无法被计算到,它就是(10000000)_b。你可以尝试把它转换成二进制原码,你会发现,根本无法转换!这时候我们把(10000000)_b人为定义成(-128)_{10}。为什么这么定义?你可以对它计算一下,你发现,当你计算(-128)+1时,它的结果奇迹般的是(-127)(这个过程我就不写了)。而你计算(-128)+(-1)的时候,它竟然成为了+127!这个过程是这样的:(-128)+(-1)=(10000000)_b+(11111111)_b=(1\ 01111111)_b=(01111111)_b=(+127)_{10}。这就牵扯到储存机制。1byte的数字可以储存从-128~127的数字,这个范围是-2^7~2^7-1。占用4bytes的int整型则可以储存从-2147483648~2147483647也就是-2^{31}~2^{31}-1。上面的7和31就是储存数据的位数。二进制补码就决定了当我们的数字越界的时候,最小的数字继续小下去,就会从最大的那个再小一个轮回;同样最大的数字继续大下去,就会从最小的那个再大一个轮回。

    以上就是计算机二进制数据储存的原理。

    展开全文
  • /* num是整型变量,设为9 */  float* pFloat=&num; /* pFloat表示num的内存地址,但是设为浮点数 */  printf("num的值为:%d\n",num); /* 显示num的整型值 */  printf("*pFloat的值为:%f\n",*pFloat)

    测试程序

    前几天,我在读一本C语言教材,有一道例题:

    #include <stdio.h>
    
      void main(void){
    
        int num=9; /* num是整型变量,设为9 */
    
        float* pFloat=&num; /* pFloat表示num的内存地址,但是设为浮点数 */
    
        printf("num的值为:%d\n",num); /* 显示num的整型值 */
    
        printf("*pFloat的值为:%f\n",*pFloat); /* 显示num的浮点值 */
    
        *pFloat=9.0; /* 将num的值改为浮点数 */
    
        printf("num的值为:%d\n",num); /* 显示num的整型值 */
    
        printf("*pFloat的值为:%f\n",*pFloat); /* 显示num的浮点值 */
    
      }

    运行结果如下:

    num的值为:9
      *pFloat的值为:0.000000
      num的值为:1091567616
      *pFloat的值为:9.000000

    num和*pFloat在内存中明明是同一个数,为什么浮点数和整数的解读结果会差别这么大?

    整数在计算机内的表示

    在讨论浮点数之前,先看一下整数在计算机内部是怎样表示的。

    int num=9;

    上面这条命令,声明了一个整数变量,类型为int,值为9(二进制写法为1001)。普通的32位计算机,用4个字节表示int变量,所以9就被保存为00000000 00000000 00000000 00001001,写成16进制就是0x00000009。

    那么,我们的问题就简化成:为什么0x00000009还原成浮点数,就成了0.000000?

    浮点数在计算机内的表示

    根据国际标准IEEE 754,任意一个二进制浮点数V可以表示成下面的形式:

           (1)s表示符号位,当s=0,V为正数;当s=1,V为负数。

      (2)M表示有效数字,大于等于1,小于2。

      (3)2^E表示指数位。

    举例来说,十进制的5.0,写成二进制是101.0,相当于1.01×2^2。那么,按照上面V的格式,可以得出s=0,M=1.01,E=2。

    十进制的-5.0,写成二进制是-101.0,相当于-1.01×2^2。那么,s=1,M=1.01,E=2。

    IEEE 754规定,对于32位的浮点数,最高的1位是符号位s,接着的8位是指数E,剩下的23位为有效数字M。

    对于64位的浮点数,最高的1位是符号位S,接着的11位是指数E,剩下的52位为有效数字M。

    这里原作者没有讨论浮点数有实际小数的情况,我补充一下。比如对于十进制的浮点数5.5,它的整数部分的二进制是101,它的小数部分0.5的二进制表示是1,即5.5的二进制表示为101.1,为什么?因为小数部分的权值不一样,5是通过1 x 2^2 + 1 x 2^0计算出来的,0.5则是通过1 x 2^(-1)计算出来的,小数部分从左到右的权值分别为2^(-1),2^(-2)...

    IEEE 754对有效数字M和指数E的规定

    前面说过,1≤M<2,也就是说,M可以写成1.xxxxxx的形式,其中xxxxxx表示小数部分。IEEE 754规定,在计算机内部保存M时,默认这个数的第一位总是1,因此可以被舍去,只保存后面的xxxxxx部分。比如保存1.01的时候,只保存01,等到读取的时候,再把第一位的1加上去。这样做的目的,是节省1位有效数字。以32位浮点数为例,留给M只有23位,将第一位的1舍去以后,等于可以保存24位有效数字。

    至于指数E,情况就比较复杂。

    首先,E为一个无符号整数(unsigned int)。这意味着,如果E为8位,它的取值范围为0~255;如果E为11位,它的取值范围为0~2047。但是,我们知道,科学计数法中的E是可以出现负数的,所以IEEE 754规定,E的真实值必须再减去一个中间数,对于8位的E,这个中间数是127;对于11位的E,这个中间数是1023。

    比如,2^10的E是10,所以保存成32位浮点数时,必须保存成10+127=137,即10001001。

    然后,指数E还可以再分成三种情况:

    (1)E不全为0或不全为1。这时,浮点数就采用上面的规则表示,即指数E的计算值减去127(或1023),得到真实值,再将有效数字M前加上第一位的1。

    (2)E全为0。这时,浮点数的指数E等于1-127(或者1-1023),有效数字M不再加上第一位的1,而是还原为0.xxxxxx的小数。这样做是为了表示±0,以及接近于0的很小的数字。

    (3)E全为1。这时,如果有效数字M全为0,表示±无穷大(正负取决于符号位s);如果有效数字M不全为0,表示这个数不是一个数(NaN)。

    结论

    好了,关于浮点数的表示规则,就说到这里。

    下面,让我们回到一开始的问题:为什么0x00000009还原成浮点数,就成了0.000000?

    首先,将0x00000009拆分,得到第一位符号位s=0,后面8位的指数E=00000000,最后23位的有效数字M=000 0000 0000 0000 0000 1001。

    由于指数E全为0,所以符合上一节的第二种情况。因此,浮点数V就写成:

    V=1×0.00000000000000000001001×2^(-126)=1.001×2^(-146)

    显然,V是一个很小的接近于0的正数,所以用十进制小数表示就是0.000000。

    再看例题的第二部分。

    请问浮点数9.0,如何用二进制表示?还原成十进制又是多少?

    首先,浮点数9.0等于二进制的1001.0,即1.001×2^3。

    那么,第一位的符号位s=0,有效数字M等于001后面再加20个0,凑满23位,指数E等于3+127=130,即10000010。

    所以,写成二进制形式,应该是s+E+M,即0 10000010 001 0000 0000 0000 0000 0000。这个32位的二进制数,还原成十进制,正是1091567616。

     

    本文转载自:http://www.ruanyifeng.com/blog/2010/06/ieee_floating-point_representation.html

    展开全文
  • 在C语言某个程序当中需要把文本16进制转换成对应的16进制数,比如字符串"0x1a"转换成10进制的26,可以用以下函数来实现相关函数: atof, atoi, atol, strtod, strtoul表头文件: #include 定义函数: long int strtol...
  • 自己的需求:有四个变量,寻求最优化的结果。 跟那些用二元函数举例的不同。 首先介绍下, 1. 遗传算法的流程: 假设有100个个体,计算每个个体的适应度(即性能),通过轮盘算法,选择100个个体,这100个不是...
  • 二进制转十进制

    2021-06-19 04:51:47
    二进制转十进制计算器二进制:十进制:进制:进制:转换说明:上面第一行可将二进制转换为十进制,第二行可以将任意进制转换为任意进制。64个基数为:"[emailprotected]"注意:本工具只是各种进制计数法的数之间的...
  • 文章目录方法一:直接输出方法:itoa函数 方法一:直接输出 C语言中,控制printf函数输出格式的是格式字符,printf没有直接打出2进制数的格式符,直接打出16进制的格式符是x格式符,即%x。 printf函数中输出的...
  • python 二进制与十进制之间的转换

    千次阅读 2020-11-21 03:03:13
    1、十进制 与 二进制之间的转换(1)、十进制转换为二进制,分为整数部分和小数部分整数部分方法:除2取余法,即...下面举例:例:将十进制的168转换为二进制得出结果 将十进制的168转换为二进制,(10101000)2168...
  • JAVA-二进制基础

    2021-02-12 12:50:53
    一、二进制的概念计算机进制有:二进制、八进制、十六进制进制的基本特点是:每一位置上的数字必须在0-(进制-1)的范围内,也就是说二进制只能有0、1;八进制为:0-7;十六进制比较特殊为:0-9,A(10) B(11) C(12) D...
  • 文本文件和二进制文件的区别

    千次阅读 2020-12-18 12:53:05
    定义广义的二进制文件即指文件,由文件在外部设备的存放形式为二进制而得名。狭义的二进制文件即除文本文件以外的文件。文本文件是一种由很多行字符构成的计算机文件。文本文件存在于计算机系统中,通常在文本文件...
  • Discuz! 要求用户在上传 PHP 程序文件时,使用二进制的上传方式进行。原因为某些程序文件经过编译处理...以下举例说明这两种客户端软件设置 PHP 文件二进制上传的方法。LeapFTP:在 Options(选项)菜单中选择 Paramet...
  • MATLAB读二进制文件

    千次阅读 2020-01-06 21:14:18
    fopen : 打开文件,以二进制形式访问,并返回大于或等于3的整数,作为文件标识符。(MATLAB® 保留文件标识符 0、1 和 2 分别用于标准输入、标准输出(屏幕)和标准错误。)如果fopen无法打开文件,则返回-1. ...
  • 二进制数的运算方法

    万次阅读 多人点赞 2017-08-29 14:12:13
    1.二进制数的算术运算 二进制数的算术运算包括:加、减、乘、除四则运算,下面分别予以介绍。 (1)二进制数的加法 根据“逢二进一”规则,二进制数加法的法则为: 0+0=0 0+1=1+0=1 1+1=0 (进位为1)...
  • 二进制基础

    2019-06-29 13:52:33
    阅读源码时,会出现很多关于二进制基础和位运算的东西,再次进行一个巩固和记录。 如果想详细了解的,可以去看这个链接下的视频,讲的非常棒。https://www.imooc.com/video/3649 1.二进制的概念 1.1 二进制与十进制...
  • GDB不仅可以用来调试程序,还可以直接修改被调试程序的二进制文件。这种方式相比于改源码重新编译、gdb attach有什么优势呢?考虑以下企业生产环境中的几个调试场景: 需要修改的二进制文件是其他领域的,你没有...
  • 一、二进制a = 1bin(a)-->ob1 #python内置方法ob 表示二进整型制格式二、难缠符号1、位移二进制的位>> 右位移,想象成 切肉切去最后一位例如 x >> y #先转成二进制再位移计算公式:x/(2**y)<< ...
  • 详细介绍了C中文件操作的常用方法,包括文件指针的创建于关闭,文件指针的移动,文本文件的读写,二进制文件的读写等
  • 先详细补充二进制的所有内容,整合二进制涉及的所有算法
  • 1、float 浮点数 ...阶码表示基的指数,因为是二进制,因此基是2,表示为2^n,阶数需要转换时需要±127 尾数表示小数点后面的数,需要由二进制转换成小数点后的数 在实际的物理存储中又分为如下长度:
  • C语言里求一个整数的二进制位数

    千次阅读 2022-04-19 16:26:50
    我们可以看到计算11的二进制先计算11/2作为下一个被除数,再计算11%2我们知道一个数摸2的结果只有可能是0或者1,如果是1,则计数器加一这是一次计算,接下来再以11/5的结果作为下一次计算,重复上述步骤即可 ...
  • 二进制加,减法,23个位运算技巧

    千次阅读 2019-04-06 20:36:22
    二进制加,减法 二进制最高位为1时表示负数,为0时表示正数。 **原码:**一个正数,转换为二进制位就是这个正数的原码。负数的绝对值转换成二进制位然后在高位补1就是这个负数的原码。 举例说明:  int类型的 3 的...
  • 浮点数的二进制表示

    2020-03-20 12:36:33
    前几天,我在读一本C语言教材,有一道例题: ... /* num是整型变量,设为9 */  float* pFloat=&num; /* pFloat表示num的内存地址,但是设为浮点数 */  printf("num的值为:%d\n",num); /*...
  • JavaScript-二进制二进制数组

    万次阅读 2016-07-03 18:09:40
    在ES5中引入了Blob用于处理二进制。在ES6中引入了ArrayBuffer、TypedArray、DataView用于处理二进制数组。常规的前端操作用,用到二进制的地方不多。但是,当我想处理文件的传输时候,使用二进制进行传输可以更快。...
  • 位运算及如何将一个十进制数转化为二进制
  • 通常我们交换两个变量都会用一个中间值来存储然后交换,用int来举例: int a = 1, b = 2; int temp;//中间值 temp=a,a=b,b=temp; 这样就很简单,我们也可以用差值法 int a = 1, b = 2; a=a+b; b=a-b; a=a-b; ...
  • 遗传算法 基本概念 模拟自然界优胜劣汰的进化现象,把搜索空间...比如:x∈[0,10] 如果设置二进制的长度为10,这二进制最大可以表示1023,若要取10则,1023只可以除以100。则10位二进制可以提供的精度为0.01。
  • python基础入门学习笔记1:输入输出,二进制字符编码,数据类型与注释
  • 带你看明白class二进制文件!

    千次阅读 2021-08-24 14:27:19
    源代码经过编译器编译之后便会生成一个字节码文件,字节码是一种二进制的类文件,它的内容是JVM的机器码指令,而不像C、C++经由编译器直接生成机器码。 2.什么是字节码指令(bytecode)? Java虚拟机的指令由...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,444
精华内容 29,377
热门标签
关键字:

二进制变量举例