精华内容
下载资源
问答
  • C语言 二进制转任意进制

    千次阅读 2017-06-28 13:38:53
    将输入的0和1数字序列表示二进制数转换为八进制、十六进制数。 (2)功能要求 ①将输入的0和1数字序列存放到数组中。 ②从终端输入要转换的进制。 ③将转换后的结果保存到数组中,并以适当的形式输出。 ④若...

    二进制转任意进制

    任务描述
    将输入的0和1数字序列表示的二进制数转换为八进制、十六进制数。
    功能要求
    ①将输入的0和1数字序列存放到数组中。
    ②从终端输入要转换的进制。
    ③将转换后的结果保存到数组中,并以适当的形式输出。
    ④若要转换成任意进制数,程序应如何编写?

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct {
        char elements[100];
        int top;
    }Stack;
    
    int pow(int num, int n) {
        int i, cheng = num;
        if (n == 0) {
            return 1;
        }
        for (i = 0; i < n-1; i++) {
            num  = num * cheng;
        }
        return num;
    }
    int bin2dec(char *binary)
    {
        int index = strlen(binary) - 1;
        int i,n = 0;
        int dec = 0;
        for (i = index; i >= 0; i--) {
            dec += (binary[i] - '0')* pow(2, n);
            n++;
        }
        return dec;
    }
    
    int dec2eve(int dec, int jinZhi)
    {
        Stack s;
        int temp, index = 0, i;
        s.top = 0;
        while (dec) {
            temp = dec % jinZhi;
            if (temp < 10) {
                s.elements[s.top] = temp + '0';
                index++;
                s.top++;
            }
            else {
                s.elements[s.top] = temp - 10 + 'A';
                index++;
                s.top++;
            }
            dec /= jinZhi;
        }
    
        for (i = 0; i < index; i++) {
            s.top--;
            printf("%c", s.elements[s.top]);
    
        }
        printf("\n");
    }
    
    
    int main()
    {
        char bin[16];
        int dec, jinzhi;
        printf("输入一个二进制数:\n");
        scanf("%s", bin);
        dec = bin2dec(bin);
        printf("十进制:%d", dec);
        printf("\n输入要转换的进制: ");
        scanf("%d", &jinzhi);
        printf("%d进制:",jinzhi);
        dec2eve(dec, jinzhi);
        system("pause");
        return 0;
    }
    展开全文
  • 那么如何通过在标准C语言环境中,使用二进制常量,就是本文探讨的问题。基本的思路是在预编译期间,通过多遍宏替换,将二进制常量替换成十六进制常量。以B8(10011001)为例,经过三遍宏替换,最终得到0x99:B8(1001.....

    C语言标准中针对数值常量,规定了八进制、十进制和十六进制的规则,但是对于常用的二进制则没有规定。

    一些编译器厂商,自行扩展了类似0b10001000这样的语法,用来表示二进制数值。

    那么如何通过在标准C语言环境中,使用二进制常量,就是本文探讨的问题。

    基本的思路是在预编译期间,通过多遍宏替换,将二进制常量替换成十六进制常量。

    以B8(10011001)为例,经过三遍宏替换,最终得到0x99:

    B8(10011001) => _B8(B10011001) => __B8(99) => 0x99

    #include

    #include

    #include

    #define B00000000 00

    #define B00000001 01

    #define B00000010 02

    #define B00000011 03

    #define B00000100 04

    #define B00000101 05

    #define B00000110 06

    #define B00000111 07

    #define B00001000 08

    #define B00001001 09

    #define B00001010 0A

    #define B00001011 0B

    #define B00001100 0C

    #define B00001101 0D

    #define B00001110 0E

    #define B00001111 0F

    #define B00010000 10

    #define B00010001 11

    #define B00010010 12

    #define B00010011 13

    #define B00010100 14

    #define B00010101 15

    #define B00010110 16

    #define B00010111 17

    #define B00011000 18

    #define B00011001 19

    #define B00011010 1A

    #define B00011011 1B

    #define B00011100 1C

    #define B00011101 1D

    #define B00011110 1E

    #define B00011111 1F

    #define B00100000 20

    #define B00100001 21

    #define B00100010 22

    #define B00100011 23

    #define B00100100 24

    #define B00100101 25

    #define B00100110 26

    #define B00100111 27

    #define B00101000 28

    #define B00101001 29

    #define B00101010 2A

    #define B00101011 2B

    #define B00101100 2C

    #define B00101101 2D

    #define B00101110 2E

    #define B00101111 2F

    #define B00110000 30

    #define B00110001 31

    #define B00110010 32

    #define B00110011 33

    #define B00110100 34

    #define B00110101 35

    #define B00110110 36

    #define B00110111 37

    #define B00111000 38

    #define B00111001 39

    #define B00111010 3A

    #define B00111011 3B

    #define B00111100 3C

    #define B00111101 3D

    #define B00111110 3E

    #define B00111111 3F

    #define B01000000 40

    #define B01000001 41

    #define B01000010 42

    #define B01000011 43

    #define B01000100 44

    #define B01000101 45

    #define B01000110 46

    #define B01000111 47

    #define B01001000 48

    #define B01001001 49

    #define B01001010 4A

    #define B01001011 4B

    #define B01001100 4C

    #define B01001101 4D

    #define B01001110 4E

    #define B01001111 4F

    #define B01010000 50

    #define B01010001 51

    #define B01010010 52

    #define B01010011 53

    #define B01010100 54

    #define B01010101 55

    #define B01010110 56

    #define B01010111 57

    #define B01011000 58

    #define B01011001 59

    #define B01011010 5A

    #define B01011011 5B

    #define B01011100 5C

    #define B01011101 5D

    #define B01011110 5E

    #define B01011111 5F

    #define B01100000 60

    #define B01100001 61

    #define B01100010 62

    #define B01100011 63

    #define B01100100 64

    #define B01100101 65

    #define B01100110 66

    #define B01100111 67

    #define B01101000 68

    #define B01101001 69

    #define B01101010 6A

    #define B01101011 6B

    #define B01101100 6C

    #define B01101101 6D

    #define B01101110 6E

    #define B01101111 6F

    #define B01110000 70

    #define B01110001 71

    #define B01110010 72

    #define B01110011 73

    #define B01110100 74

    #define B01110101 75

    #define B01110110 76

    #define B01110111 77

    #define B01111000 78

    #define B01111001 79

    #define B01111010 7A

    #define B01111011 7B

    #define B01111100 7C

    #define B01111101 7D

    #define B01111110 7E

    #define B01111111 7F

    #define B10000000 80

    #define B10000001 81

    #define B10000010 82

    #define B10000011 83

    #define B10000100 84

    #define B10000101 85

    #define B10000110 86

    #define B10000111 87

    #define B10001000 88

    #define B10001001 89

    #define B10001010 8A

    #define B10001011 8B

    #define B10001100 8C

    #define B10001101 8D

    #define B10001110 8E

    #define B10001111 8F

    #define B10010000 90

    #define B10010001 91

    #define B10010010 92

    #define B10010011 93

    #define B10010100 94

    #define B10010101 95

    #define B10010110 96

    #define B10010111 97

    #define B10011000 98

    #define B10011001 99

    #define B10011010 9A

    #define B10011011 9B

    #define B10011100 9C

    #define B10011101 9D

    #define B10011110 9E

    #define B10011111 9F

    #define B10100000 A0

    #define B10100001 A1

    #define B10100010 A2

    #define B10100011 A3

    #define B10100100 A4

    #define B10100101 A5

    #define B10100110 A6

    #define B10100111 A7

    #define B10101000 A8

    #define B10101001 A9

    #define B10101010 AA

    #define B10101011 AB

    #define B10101100 AC

    #define B10101101 AD

    #define B10101110 AE

    #define B10101111 AF

    #define B10110000 B0

    #define B10110001 B1

    #define B10110010 B2

    #define B10110011 B3

    #define B10110100 B4

    #define B10110101 B5

    #define B10110110 B6

    #define B10110111 B7

    #define B10111000 B8

    #define B10111001 B9

    #define B10111010 BA

    #define B10111011 BB

    #define B10111100 BC

    #define B10111101 BD

    #define B10111110 BE

    #define B10111111 BF

    #define B11000000 C0

    #define B11000001 C1

    #define B11000010 C2

    #define B11000011 C3

    #define B11000100 C4

    #define B11000101 C5

    #define B11000110 C6

    #define B11000111 C7

    #define B11001000 C8

    #define B11001001 C9

    #define B11001010 CA

    #define B11001011 CB

    #define B11001100 CC

    #define B11001101 CD

    #define B11001110 CE

    #define B11001111 CF

    #define B11010000 D0

    #define B11010001 D1

    #define B11010010 D2

    #define B11010011 D3

    #define B11010100 D4

    #define B11010101 D5

    #define B11010110 D6

    #define B11010111 D7

    #define B11011000 D8

    #define B11011001 D9

    #define B11011010 DA

    #define B11011011 DB

    #define B11011100 DC

    #define B11011101 DD

    #define B11011110 DE

    #define B11011111 DF

    #define B11100000 E0

    #define B11100001 E1

    #define B11100010 E2

    #define B11100011 E3

    #define B11100100 E4

    #define B11100101 E5

    #define B11100110 E6

    #define B11100111 E7

    #define B11101000 E8

    #define B11101001 E9

    #define B11101010 EA

    #define B11101011 EB

    #define B11101100 EC

    #define B11101101 ED

    #define B11101110 EE

    #define B11101111 EF

    #define B11110000 F0

    #define B11110001 F1

    #define B11110010 F2

    #define B11110011 F3

    #define B11110100 F4

    #define B11110101 F5

    #define B11110110 F6

    #define B11110111 F7

    #define B11111000 F8

    #define B11111001 F9

    #define B11111010 FA

    #define B11111011 FB

    #define B11111100 FC

    #define B11111101 FD

    #define B11111110 FE

    #define B11111111 FF

    #define __B8(B0) 0x##B0

    #define _B8(B0) __B8(B0)

    #define B8(B0) _B8(B##B0)

    #define __B16(B1, B0) 0x##B1##B0

    #define _B16(B1, B0) __B16(B1, B0)

    #define B16(B1, B0) _B16(B##B1, B##B0)

    #define __B32(B3, B2, B1, B0) 0x##B3##B2##B1##B0

    #define _B32(B3, B2, B1, B0) __B32(B3, B2, B1, B0)

    #define B32(B3, B2, B1, B0) _B32(B##B3, B##B2, B##B1, B##B0)

    const char * bin(unsigned int value, int width)

    {

    static char binstr[33];

    int pos;

    if(width < 0 || width > 32) return NULL;

    binstr[width] = 0;

    for(pos = width - 1; pos >= 0; pos--)

    {

    binstr[pos] = (value & 0x01) ? '1' : '0';

    value >>= 1;

    }

    return binstr;

    }

    int main()

    {

    int value8 = B8(10011001);

    int value16 = B16(10011001,10101010);

    int value32 = B32(10011001,10101010,10111011,11001100);

    int i;

    printf("0x%08X, 0b%s\n", value8, bin(value8, 8));

    printf("0x%08X, 0b%s\n", value16, bin(value16, 16));

    printf("0x%08X, 0b%s\n", value32, bin(value32, 32));

    for(i = 0; i < 256; i++)

    {

    printf("#define B%s %02X\n", bin(i, 8), i);

    }

    system("PAUSE");

    return 0;

    }

    通过gcc -E输出预编译后的代码,可以看到main函数中的二进制已经替换成十六进制形式:

    int main()

    {

    int value8 = 0x99;

    int value16 = 0x99AA;

    int value32 = 0x99AABBCC;

    int i;

    printf("0x%08X, 0b%s\n", value8, bin(value8, 8));

    printf("0x%08X, 0b%s\n", value16, bin(value16, 16));

    printf("0x%08X, 0b%s\n", value32, bin(value32, 32));

    for(i = 0; i < 256; i++)

    {

    printf("#define B%s %02X\n", bin(i, 8), i);

    }

    system("PAUSE");

    return 0;

    }

    程序输出如下:

    0x00000099, 0b10011001

    0x000099AA, 0b1001100110101010

    0x99AABBCC, 0b10011001101010101011101111001100

    #define B00000000 00

    #define B00000001 01

    #define B00000010 02

    此处省略若干行。。。

    #define B11111101 FD

    #define B11111110 FE

    #define B11111111 FF

    请按任意键继续. . .

    展开全文
  • C语言进制

    2016-01-06 13:24:00
    本文目录 • 一、十进制 • 二、二进制 • 三、八进制 • 四、十六进制 • 五、进制总结 • 六、变量与进制 • 七、printf的简单使用上一讲简单介绍了常量和变量,这讲补充一点计算机的基础知识---进制。我们先来看...
    本文目录
    一、十进制
    二、二进制
    三、八进制
    四、十六进制
    五、进制总结
    六、变量与进制
    七、printf的简单使用
    上一讲简单介绍了常量和变量,这讲补充一点计算机的基础知识---进制。
    我们先来看看平时是如何表示一个整数的,最常见的肯定是用阿拉伯数字表示,比如“十二”,我们可以用12来表示,其实这种表示方式是基于一种叫做“十进制”的计数方式。“进制”是一种计数方式,编程中常见的进制有4种:十进制、二进制、八进制、十六进制。也就是说,同一个整数,我们至少有4种表示方式。
    回到顶部
    一、十进制
    1.概念
    十进制是我们最熟悉、最常用的一种计数方式,它有两个特点:由0、1、2….9十个基本数字组成;运算规则是“逢十进一”。
     
    2.运算
    所谓“逢十进一”,似乎在小学数学中都已经学过了,也就是当数值满十时,就要向前进一位
     
    个位数为9+1,满十了,十位数就进一。
     
    回到顶部
    二、二进制
    1.概念
    二进制是计算机内部使用的一种计数方式,它有两个特点:由0、1两个基本数字组成;运算规则是“逢二进一”。
     
    2.细节
    1> 有人可能会问:为什么二进制里面没有2~9这些数字呢?都说了,逢二进一,因此当数字满二的时候就会进位。
    2> 如果我写个1010,你能看出它是二进制还是十进制么?为了跟其他进制区分开来,书写二进制数的时候,需要以0b或者0B开头。比如0b1010是个二进制数,而1010则还是我们熟悉的十进制数,就是“一千零一十”
     
    3.运算
    做个简单的运算吧,比如1+1
     
    个位数是1+1,值满二了,于是十位数要进一。因此,在二进制中:1 + 1 = 0b10,这里的0b10表示的是十进制中的“二”,并不是“十”。
     
    以此类推,11 + 1 = 0b100
     
     
    4.二进制转为十进制
    1> 用二进制表示数值,虽然简单、方便,但是不容易阅读,比如随便给出个二进制数0b110111101010,你能立刻看出它表示的是什么数值吗?一般需要将二进制数转为十进制数后才能知道代表的什么数值。
    进制里面有个“基数”的概念,基数是用来计算数值的,比如十进制的基数是10,因此十进制是这样算数的:
    1230 = 0 * 100 + 3 * 101 + 2 * 102 + 1 * 10= 0 * 1 + 3 * 10 + 2 * 100 + 1 * 1000
    二进制的基数是2,以此类推:
    0b1011 = 1 * 20 + 1 * 21 + 0 * 22 + 1 * 23 = 1 * 1 + 1 * 2 + 0 * 4 + 1 * 8 = 1 + 2 + 0 + 8 = 11
    因此二进制数0b1011表示的数值是十进制中的11
     
    2> 一位二进制数能表示的最大值是1,而n位二进制数所能表示的最大值是0b111...1111,也就是说n位二进制数都是1,那么它的十进制数值为:
    1 * 20 + 1 * 21 + 1 * 22 + 1 * 2+ .... + 1 * 2n-1 = 2n - 1

    因此,n位二进制数所能表示的最大值是2n - 1。也就是说,4位二进制数能表示的最大值是0b1111,十进制数值为:24 - 1 = 15;5位二进制数能表示的最大值是25 - 1 = 31。
     
    回到顶部
    三、八进制
    1.概念
    八进制有两个特点:由0~7八个基本数字组成;运算规则是“逢八进一”。
     
    2.细节
    由于十进制和八进制中都包含了0~7,为了区分开来,在书写八进制数的时候,需要在前面加个0。比如076是个八进制数,76则是个十进制数。
     
    3.运算
     
    个位数是7+1,值满八了,于是十位数要进一。因此,在八进制中,7 + 1 = 010。010则表示十进制中的“八”,而不是“十”
     
    4.八进制转十进制
    八进制的基数是8,因此027计算出来就是十进制中的23
    027 = 7 * 80 + 2 * 81 = 7 * 1 + 2 * 8 = 23
     
    5.二进制转八进制
    不难发现一个十进制数可以表示的最大值是9,而一个八进制数可以表示的最大值是7,恰好3个二进制数可以表示的最大值0b111也是7。因此,我们可以用一个八进制数来代替3个二进制数。
    0b11110011 = 0b 011  110  011  = 0363
    如果是八进制转为二进制,那就反过来,用3位二进制数来表示1位八进制数
    025 = 0b 010  101 0b10101
     
    回到顶部
    四、十六进制
    1.概念
    十六进制有两个特点:由0~9和A~F组成,A~F分别表示10~15;运算规则是“逢十六进一”。
     
    2.细节
    由于十进制、八进制、十六进制中都包含了0~7,为了区分开来,在书写十六进制数的时候,需要在前面加个0x或者0X。比如0x76是个十六进制数,076是个八进制数,76则是个十进制数。
     
    3.运算
     
    个位数是B+5,也就是11+5,值满十六了,于是十位数要进一。因此,在十六进制中,B + 5 = 0x10。0x10则表示十进制中的“十六”,而不是“十”
     
    4.十六进制转十进制
    十六进制的基数是16,F表示十进制中的15,因此0x2F计算出来就是十进制中的47
    0x2F = 15 * 160 + 2 * 161 = 15 * 1 + 2 * 16 = 47
     
    5.二进制转十六进制
    一个十六进制数可以表示的最大值是15,恰好4个二进制数可以表示的最大值0b1111也是15。因此,我们可以用一个十六进制数来代替4个二进制数。
    0b11110011 = 0b 1111  0011  = 0xF3
    如果是十六进制转为二进制,那就反过来,用4位二进制数来表示1位十六进制数
    0x25 = 0b 0010  0101=0b100101
     
    回到顶部
    五、进制总结
    1.一个整数“十二”的4种表示方式分别如下:
    十进制:12
    二进制:0b1100
    八进制:014
    十六进制:0xC
     
    2.其实也可以利用Mac中的计算器软件来测试进制之间的转换。
    设置计算机的显示模式为“编程器”
    先选择10进制,然后输入12,底部显示的二进制数为1100,这里省略最前面的0b
    选择八进制,显示为14,这里省略了最前面的0
    选择十六进制,显示为 0xC
    六、变量与进制
    1.上一讲学习了变量的使用,简单回顾一下
    1int main()
    2{
    3int a = 10;
    4return0;
    5 }
    在第3行定义了一个变量a,存储的是十进制整数10。其实,这个变量a在内存中是以二进制数的形式存储的,10的二进制形式是1010。
    2.除了十进制整数,还可以将其他进制的整数赋值给整型变量
    int main(){
     int a = 0b110; // 十进制数:6 4 5int b = 021; // 十进制数:int c = 12; // 十进制数:12 8 9int d = 0x1D; // 十进制数:291011
    return0;
    }
    上面的代码中,分别将4种不同进制的数值赋值给不同的整型变量。对应的十进制数值已经写在右边的注释中。它们最终都是以二进制的形式存储在内存中。

    转载于:https://www.cnblogs.com/GhostKZShadow/p/5105215.html

    展开全文
  • c语言:进制和位运算

    2015-07-23 19:19:00
    一.进制 十进制转n进制: 连除倒取余. 以 10 为例,不同进制的表示方法: ... 二进制: 0b1010; 八进制: 010; 十六进制: 0x10; int a = 100; printf("%o",a); /* 如何输出进制数: %d...
    一.进制
    十进制转n进制: 连除倒取余.

    以 10 为例,不同进制的表示方法:

         十进制: 10;

         二进制: 0b1010;

         八进制: 010;

         十六进制: 0x10;

         

         

        

       int a = 100;

       printf("%o",a);

        /*

         如何输出进制数:

         %d ------ 十进制

         %o  ------ 八进制

         %0x ----- 十六进制

         */

        /*

         位运算符:按位与 &, 按位或 |, 按位非 ~, 按位异或 ^, 左移 <<, 右移 >>

         按位与 & : 同1 为 1,否则为 0,经常用于对某一位清零.

         按位或 | : 同0 为 0,否则为1.经常用于保留某一位,

         按位非 ~ : 如果是一个有符号的数,则最高位代表符号位,1 代表负数, 0 代表正数,

                   数据在内存中存储时,是以补码的形式存储的,正数的补码是本身,负数的补码是 绝对值 取反 加 1 .

         按位异或 ^ : 相同为 0,不同为 1 ;

         */

        左移 << :

        unsigned char d = 1;

       printf("%d",d << 4);

        右移 >>

        unsigned char a = 255;

        printf("%d",a >> 1);

        unsigned char number = 0b01100100;

        unsigned char left = number << 4;

        unsigned char right = number >> 4;

        unsigned char result = left | right;

        printf("%d",result);

       /*

        //将 10010010 奇偶位互换

        unsigned char num = 0b10010010;

        //清零操作使用 按位&, 保留的位数为 1 ,清 0 数位为 0 ;

        //1.将奇数位变偶数位,左移一位

        unsigned char left = num << 1;

        //2.保留偶数位,奇数位清 0

        unsigned char clearJi = left & 10101010;

        //3.将偶数位变奇数位,右移一位

        unsigned char right = num >> 1;

        //4.保留奇数位偶数位清0

        unsigned char clearOu = right & 01010101;

        //5.最后按位或 |

        unsigned char result = clearJi | clearOu;

        printf("%d",result);

        

     */

        

        /*

         数据类型的取值范围: 

         无符号: char 类型  0 -- 255 (2 的8次方 - 1);

                short     0 -- 2的16次方 - 1;

                int       0 -- 2的32次方 - 1;

         有符号: char    -2 的 7次方 -- 2 的7次方 - 1;

                short   -2 的15次方 -- 2 的15次方 - 1;

                int     -2 的31次方 -- 2 的31次方 - 1;

         */

        char b = ~4;

        int a = 5 ^ 7;

        printf("%d",b);

        

      //栈区内存分配原则: 由高到低分配, 由低到高存取.

        int a = -5;

        printf("%p\n",&a);

        int b = 10;

        printf("%p\n",&b);

        

        //数组名代表数组的首地址,也就是数组的第一个元素地址,是一个常量地址

        int a[4] = {1, 2, 3, 4};

        printf("%d\n", &a[0]);

        printf("%p\n", &a[1]);

        printf("%p\n", &a[2]);

        printf("%p\n", &a[3]);

        printf("%p\n", &a);

        //交换两个数的值 不借助第三方变量

        int a = 20;//1001

        int b = 36;//0101

        printf("交换前 a = %d,b = %d\n",a, b);

        a = a ^ b;//1100

        b = b ^ a;//1001

        a = a ^ b;//0101

        printf("交换后 a = %d,b = %d\n",a, b);

     

    转载于:https://www.cnblogs.com/hanpengshuai/p/4671457.html

    展开全文
  • C语言如何表示相应进制数 代码示例: #include<stdio.h> int main() { //二进制0-1 八进制0-7 十六进制0-9 10-15(a-f A-F) //int a = 10; //printf("%d\n", a); ////占位符 %x,输出一个十六进制
  • KEIL for 51和RealView MDK就不能使用类似 ... 这样的表示二进制数的方法,有时候不方便。解决小技巧参考文章:http://ask.zol.com.cn/x/9159373.html #ifndef __BINARY_H__ #define __BINARY_H__ #define B32(...
  • B 二进制 Binary 的缩写 O 八进制 Octal 的缩写 Q 八进制 Octal 的缩写 避免字母O误认作数字0,标识改为Q D 十进制 Decimal的.八进制用什么字母表示? “H”表示“十六进制”; “K”表示“十进制”; “.八进制用...
  • C语言中使用二进制常量

    万次阅读 2012-08-08 11:30:00
    那么如何通过在标准C语言环境中,使用二进制常量,就是本文探讨的问题。 基本的思路是在预编译期间,通过多遍宏替换,将二进制常量替换成十六进制常量。 以B8(10011001)为例,经过三遍宏替换,最终得到0x99
  • 如果给定一个十进制正整数是 如何转换成二进制数的呢?用的是除以2取余数的方法。若余数为1,则1的个数加 1;然后用商再除以2取余数,直到商为0;但是负数除2的余数为负数。因此,可以 在用 unsigned int 定义一...
  • c语言支持二进制、八进制、十进制和十六进制的计数系统,在表示一个数字时,用某个特殊的字符来区别其所属的计数系统是必要的。在表示二进制数时,要在数字的末尾加上“b”(如101b);在表示八进制数时,要使用反斜杠...
  • 比如输入-5就应该输出-5对应在内存中的表示,前提是不知道是用补码表示
  • 整数在计算机内部的表达 众所周知 在计算机的内部 ...事实上 在计算机中 二进制使用的是补码的方式来表示负数 补码 即为二进制中的11111111(请注意 并不是作为纯二进制 而是补码 若是纯二进制那么就是255了) 由于十进
  • 我突然问你,-1用二进制如何表示?你最快多久能给我答案????,-1全是1啊二进制如何表示负数最左一位表示正负----->1为负,0为正将-5用二进制表示:好的算法:(1)先加1,得-4(2)求绝对值,得4(3)二进制表示:00000100(4)求...
  • 补码与反码在计算机中对数据进行运算操作时,符号位该如何表示呢?是否也同数值位一道参加运算操作呢??如果参加,会给运算操作带来什么影响呢???为了妥善地处理好这些问题,就产生了把 符号位 和 数值位 一起来...
  • c语言支持二进制、八进制、十进制和十六进制的计数系统,在表示一个数字时,用某个特殊的字符来区别其所属的计数系统是必要的。在表示二进制数时,要在数字的末尾加上“b”(如101b);在表示八进制数时,要使用反斜杠...
  • 二进制的加减运算(原码,反码,补码的理解) 最近又看了,二进制加减法运算。对于很多新人可能对于二进制的加减法运算有不理解的...计算机需要将其转换成二进制进行存储,即以0 和1的形式来表示。 下面以单字节...
  • C的二进制表示

    千次阅读 2014-10-31 10:28:12
    对于有符号整型数的简单认识就是,最高位为符号位,0为正,1为负,那么剩下几位应该如何表示呢?理所当然的认为,既然是1表示为0000 0001(假设为8位整型数,下同),那么-1就应该表示为1000 0001了。 但是,在C语言...
  • 这个题中函数的输入n被定义为一个32位的二进制数,这在C语言中是无法直接用变量输入表示二进制数的,只能用字符数组进行存储。这里我们只需要把n当做二进制数处理就行,不用考虑它是如何实现的。 这里需要提到两个...
  • -1的二进制表示

    万次阅读 2009-02-12 17:13:00
    比如,-1的二进制表示到底是怎样的?从没有深究过,一直都是模棱两可的,说出来实在让人笑话。 对于有符号整型数的简单认识就是,最高位为符号位,0为正,1为负,那么剩下几位应该如何表示呢?理所当然的认为,既然...
  • 今天有人在问我BCD码如何转换成10进制码的问题,其实很简单BCD 的表示法是 用4个二进制位来表示 一个十进制位,也就是一个字节能够表示2个十进制数位,这是一种压缩的十进制表示方式,应用很广,最常见的就是CMOS里...
  • -1的二进制表示(转载)

    2012-10-01 14:50:24
    比如,-1的二进制表示到底是怎样的?从没有深究过,一直都是模棱两可的,说出来实在让人笑话。 对于有符号整型数的简单认识就是,最高位为符号位,0为正,1为负,那么剩下几位应该如何表示呢?理所当然的认为,既然...
  • C语言如何表示负数?

    千次阅读 2020-12-18 01:03:50
    正数的补码和二进制原码是一样的; 负数的补码是其本身绝对值的原码取反再加1. 0000 0000 表示 1 1111 1111 表示 -1 注意表示范围, 1111 1111被当作纯二进制看待时,是255,被当做补码看待时是 -1. ...
  • 比较二进制的数,可以采用按位异或(相同为0,相异为1),这样两个数按位异或后悔得到一个新的数,这个新的数的二进制,其中的1表示的是两个原二进制数这一位不同,0表示这一位是相同的。则我们只需要数一下这个新的...
  • 我们先来看看平时是如何表示一个整数的,最常见的肯定是用阿拉伯数字表示,比如“十二”,我们可以用12来表示,其实这种表示方式是基于一种叫做“十进制”的计数方式。“进制”是一种计数方式,编程中常见的进制有4...
  • C语言中的负数是如何表示的?

    千次阅读 2011-03-26 09:55:00
    例如16个1111111111111111头位是符号位,这应是-32767,那-32768怎么 用16位二进制表示? 问题补充:负数的二进制表示怎么算的? 例如: -1 的二进制 -32767 的二进制 答案: -2^15~(2^15-1) 计算机中数字是以...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 244
精华内容 97
关键字:

c语言二进制如何表示

c语言 订阅