进制转换，计算 还有各种数据类型和字符

进制的转换，还有它们之间的计算

二进制 八进制 十六进制转换成十进制

例如：（111011）=2^5+2^4+2^3+2^1+2^0

  (136）=8^2+3*8^1+6*8^0

（1F2A）=16^3+15*16^2+2*16+10*16^0

二进制转换成八进制

例如    001 101 000 101    三个一组得到结果 1 5 0 5

二进制转换成十六进制

例如  0011 0100  0101     四个一组得到结果  3 4 5

十进制转换成二进制的问题就是 除以2的问题 除不尽就写1  除尽就加0 没除一次写一次  直到剩下最后一个数 是1就写1     是0就写0

十进制小数转为二进制 方法是乘于2取整

例如  0.625*2=1.25   取整1 

0.25*2=0.5   取整0

0.5*2=1      取整1

 

 0.625（十进制）=0.101（二进制）

0.25（十进制）=0.01（二进制）

0.5 （十进制）=0.1（二进制）

 

    C语言类型  ：             构造类型    ：数组，结构体，公用体

                                         指针类型

                                          空类型（void）

                                          基本类型 ： 字符类型（char）

                                                                 枚举类型（enum）

                                                                 数值类型：整型：短整型（short）2个字节

                                                                                                    整型（int）4个字节

                                                                                                  长整型（long）

                                                                                     实型：单精度（float）

                                                                                                  双精度（double）8个字节

单目运算符 ：sizeof运算符：用来计算操作数在内存中占据的字节数                      注意sizeof不是函数

例如sizeof（long）； 返回四字节

sizeof（int）；             不确定 取决于不同的系统

sizeof（short）；      返回两字节

   运行printf（“%d”，sizeof（int））；    返回四字节

原码 反码与补码

例如                     原码                                                            反码                                                                        补码

+7                    0000 0111                                                 0000 0111                                                               0000 0111

-7                     1000 0111                                                  1111 1000                                                               1111 1001

+0                     0000 0000                                                0000 0000                                                                0000 0000

-0                       1000 0000                                               1111 1111                                                                 0000 0000

范围都是  0111 1111------1111  1111 （-127——+127）

注意：正数的原码 反码 补码为它本身

负数的原码 反码 补码最前一位是符号位  1表示正号    0表示负号

口诀：  原码转补码  先取反得到反码，在加一位（也就是进一）

               补码转原码  先退一位（也就是退一） 得到反码 然后取反 得到原码

例题

#include<stdio.h>
void main(){
   int i=31;
   int j=-2;
   printf("%x,%x",&i,&j);
   getchar();
}


0x0032F85C  fe ff ff ff cc cc cc cc cc cc cc cc 14
//-2的地址，fe用的是两个字节
显示的是补码，
f= 1 1 1 1
e= 1 1 1 0
 1 1 1 1 1 1 1 0
转换成原码
符号位不动，先减一 也就是
1 1 1 1  1 1 0 1
然后取反
1 0 0 0  0 0 1 0
得到的答案就是-2


0x0037FAD0  001f 0000 cccc cccc
//显示的是31地址  001f是用十六进制数表示的，可以转换回去
正数的原 反 补码都是它本身


例如给定一个十进制数 -33
先转换成二进制数1 0 1 0 0 0 0 1 
这就是内存中的原码       //最开头的1表示的是负号
转换成反码 1 1 0 1 1 1 1 0  //符号位不会发生改变
最后就是在最后一位加一 就是 1 1 0 1 1 1 1 1


通过程序运行获取得到的内存位置找到的数，那个数是补码
可以通过先减一再取反的办法获得原码，将原码转换成十进制就得到了原数


规则就是最开头那位不能改变，还有注意加一减一的机制

   

#include<stdio.h>
void main(){
   unsigned short i=65535;
   printf("%x",&i);    //获取i的地址(十六进制)为ffff
   i++;
   printf("%u",&i);   //获取加一后 i的地址变为了0000
   getchar();
}

类型                                   类型关键字                               长度                                               取值范围

有符号字符型                 [signed]char                                  8                                            -127——+127                                   (-2^7-----+2^7）

无符号字符型                  unsigned char                              8                                           0——255                                           (0-------2^8  -1)

有符号短整型                  [signed] short(int)                        16                                          -32767——+32767                          (-2^15-------+2^15)

无符号短整型                  unsigned short(int)                      16                                          0——65535                                       (0-------2^16)

有符号长整形                  [signed]  long（int）                   32                                           -2147483647——[phone]     

无符号长整形                  unsigned  long（int）                 32                                           0——4294967295

单精度类型                             float                                         32                                            约（-3.4*10^-38-----+3.4*10^-38）

双精度类型                          double                                       64                                             约（-1.7*10^-308------+1.7*10^-308）

浮点型数据
单精度：四个字节 有效数字6到7位
双精度：八个字节 有效数字15到16位
案例代码：






字符常量：用的是单引号‘’ 字符常量的值对应它们自身的ASCII码值
例如： char ch；
       ch=‘A’；


字符串常量：用的是双引号“”  字符串是结束标志 \0
例如   “Helloworld”  Helloworld\0


字符常量和字符串常量是两个不同的概念
区别:'a' 得到的是a
     “a”得到的结果是a\0


字符‘1’和整数1是两个不同的概念

前天不会的那个类似于bug的运算方式

源文件

 #include<stdio.h>
#include<stdlib.h>          //引用头文件
#include"niupi.h"

一 二 三 四 五
   七 三 "哈咯" 四 十
九 三 四 十
六    

                            输出的是哈咯

头文件

 #define 一 void
#define 二 main                  全局常量定义的值不会改变   分别替换 ，此程序可以运行
#define 三 (
#define 四 )
#define 五 {
#define 六 }
#define 七 printf
#define 九 getchar
#define 十 ; 

混易乱易

while（0）{

}                                        // 0代表的是false   所以此循环不会被运行

while（1）{

}                                       // 1代表的是true      所以这是一个死循环