C语言学习日记整型，浮点型，字符型数据以及算数运算的隐型类型转换

1、定义变量的方法
  1 int a；
      a = 1；
  2  int a = 1；

2、数据类型
   short            2
  int                 4
  long              8
float                4
double            8
char                  2

不同的数据类型的大小（字节数）会影响数据类型的取值范围
eg：
short分为unsigned short 和signed short
1、unsigned short【 0 ， 65535】

0000 0000 I 0000 0000   最小值
1111 1111 I 1111 1111    最大值   -------->  2 ^ 16 - 1  =     65535 
 
2、signed short   【 -32768 ， 32767】

//非负数
0  I  000 0000 0000 0000   // 0 
0  I  111 1111 1111 1111   // 2 ^ 15 - 1 = 32768 - 1 = 32767

//负数
原码：
1  I  000 0000 0000 0000  
补码：
1  I  000 0000 0000 0000    //原码值    -0   //这个值比较特殊 专门规定了，只有这一个值！符号位也是数值。       // -32768
1  I  111 1111 1111 1111    //
1  I  000 0000 0000 0001    // -1

在整型使用时，可能出现的问题是整型的溢出
分为向上溢出和向下溢出
---------------------------------------------------------------------------
浮点类型的数据：
float        // 单精度类型   4字节 
double    //双精度类型    8字节

浮点型常量
输出时用 %f
 浮点型常量的格式： 
  1.23   //小数形式
  1.23e3  //科学计数法的形式   1.23 *10 ^3
  1.23E3                     //这些都可以  
  1.23E-3

浮点数的存储
eg： 6 .125    // 0  1

第一步 ： 将十进制的小数转换为二进制形式的小数

整数部分  ----辗转相除法
  110

小数部分   ----乘2取整法
 0.125 * 2= 0.25 ----------->  取    0
0. 25 * 2 = 0.5    ---------->   取    0
0.5 * 2 = 1.0  ----------->  取  1

110.001

第二步：  IEEE 754标准存储
 把二进制形式的小数写成科学计数法
eg：
110.001 ------->1.10001 * 2^2

第三步：
按照 IEEE 754标准存储 来存储

float 
符号位（1bits）     指数位（阶码位）（8bits）   尾数位（23bits）                // 阶码就是2^（） 这个数就是阶码
   0                         +127偏移量                                         即小数点后面的
                                  2 + 127 = 129                                          10001
                                 1000 0001                                              不足的位 统统补0
0100 0000 1100 0100 0000 0000 0000 0000
  4        0      c       4        0       0       0       0 

所以6.125存储到计算机里的数据就是 0x40c40000

浮点型很难做到精准存储

比如0.9 就不能存进去 ，存进去最多只能在尾数位存23位小数，实际上还有更多。所以不精准。

float 的 0.9 < 真正的0.9

double和float类型的存储方式相似：

double类型      // 因为存储的尾数更多，所以精度更高了

符号位（1bits）     指数位（阶码位）（11bits）   尾数位（52bits）
                                     +1023偏移量   
----------------------------------------------------------------------------------------------

注意：代码中出现的常量或者变量一定有其对应的数据类型

小数默认识别为double类型
也可以这样  eg：  f ==0.9f
                              这样就让编译器默认把f识别为float类型
注意：
若是两个浮点型数据比较，为了不出差错，必须统一同一类型，同一精度。
可以显式的，指定常量的类型

浮点型常用：
float
double
long double
(浮点型不需要signed/unsigned)

---------------------------------------------------------------
字符型：
计算机中只能存储二进制的010101010101
怎么办呢？
’a‘  <--- 编码 --->  0101010   //代表’a‘

把现实的字符用0 1 符号进行编码作为代表。

ASCII  ---用数字对128个符号进行了编码  // 在Linux终端 可以用man ascii打开手册查看
在ascii编码中
0-32 不可见字符 主要起控制作用
33-127  是可见字符 

字符型变量：
char
字符型常量：
’a‘               //单个字符

字符型数据怎么储存在计算机的？
char = ’a‘；
’a‘ <-----> ascii 编码值（整型数字）
所谓的’a‘字符存到计算机，实际上存的是’a‘字符对应ascii码的值（二进制）
 本质上却还是 整型数据。。。。。（tiny int）
 
 在输出的时候用    %c 来打印   （打印出对应值的字符形式）

 注意：
 char 定义变量的时候 可以直接存十进制的数字 对应的就是相应的字符
48 -57 数字字符对应的编码值 ’0‘ ~  ’9‘（ 字符形式的0~ 9 ）
65 - 90 是大写字母       ’A‘ - ’Z‘    相对应的字符
97 - 122  是小写字母     ’a‘ - ’z‘    相对应的字符
（space 的ascii码是 32  ）    也可以这样’ ‘表示加了32 或者减了32

！计算机里存储的都是字符相对应的ASCII码的值！

字符型的大小：
    1字节 
    0000 0000
    char 前面 可以加 unsigned           和              signed 
                               0000 0000//0                1 000 0000  // - 128
                   1111 1111//255            0 111 1111  //   127

算数运算：
     + - * / % ++ --
     * 乘 
     / 除
     
     表达式：---> 由运算符 和 运算数 构成的字符序列
    
注意：
凡是表达式 必然是有值的，（一定可以计算出结果）必然有其对应的数据类型。

表达式最终结果的类型是怎么定下来的？？？
------>有专门的规则

    隐式类型转换（下表）
    （在代码运行时自动运行啦）
    从右向左，必转  参与运算就进行转换
    
    越向上精度越高，
    从下到上 如果有高精度类型和低精度类型混合运算，此时，低精度往高精度转。
    
    double  <---- float
     ^
      |
     long 
         ^
      |
unsigned （默认为 unsigned int）
     ^
      |
     int   <----  char 、 short
    
    进行转换的目的是为了保持结果的精确和准确 ，（float --->double 现在应用中在过程中转换）