嵌入式day3-创新互联

扩展：
 //打印浮点型
 printf("%m.nf",a);     // 代表该数的宽度至少是m个 ，保留的小数位数为n位
 例子：
     float a = 123456.789654;
     printf("%10.2f",a); //  代表该数的宽度至少是10个(包含了小数点)
         123456.79
 m是正数：右对齐
         (这里空了一格) 123456.79
         
 m是负数：左对齐
         123456.79 (这里空了一格)

运算符：
 * 算术运算符
     + - * / %
     int a = 10;
     char c = 'A';
     a + c;   // 变成 同类型 进行运算    75
     a - c;   // -55
     a * c;   // 650
     a / c;   //   10/65    0
     a % c;   //   10  
     
     % : 取余操作：
         attention：
             %的前后 必须 是 整数
             
printf("a %% b = %d \n",a%b);  // 对 % 做转义操作  %%

=======================
++  -- ：
 姿势 ：
     * 某一块空间++
     * ++某一块空间
     * 某一块空间--
     * --某一块空间

 例子：
     int a = 10;
     a++  :  ++在后 ， 将a的值 赋值 给 a++表达式 ，a的值再 自加1
         a = 10;
         int b = a++;    b:10    a:11
         
     ++a  :  ++在前，先a自加1 ，再将a的值 赋值 给 ++a表达式
         a = 10;
         int c = ++a ;   c:11    a:11    
         
     a-- : --在后 ， 将a的值 赋值 给 a--表达式 ，a再自减1
         a = 10;
         int b = a--;    b:10    a:9
         
     --a  :  --在前，先a自减1 ，再将a的值 赋值 给 --a表达式
         a = 10;
         int c = --a ;   c:9    a:9    
         
记住： a++ --a ++a a-- 的值 就是 a的值，首先明确a的值有没有变化

int a = 10;
int b = a++ + a++ + a++;
int c = a++ + ++a + a++;
int d = ++a + a++ + a++;
.........

=========================
 * 逻辑运算符：
     * 逻辑与(&&)  
     * 逻辑或(||)
     * 逻辑非(!)
     
==========
逻辑与(&&):
 *姿势：
     表达式1 && 表达式2
     *解析：
         如果 表达式1 为 非0 ， 表达式2 也是 非0 ，称 该 逻辑&&表达式 为真
         也就是说： 表达式1 和 表达式2 同时为真，该逻辑&& 才为真，否则为假
         
 *逻辑与 有一个智能算法：
     从左往右，只要能够确定 整个 逻辑表达式的值，则不在往后执行
     例子：
         表达式1 && 表达式2 && 表达式3 && 表达式4
         int a = 10;
         int b = 20;
         a +b && 0 && a-b;
         分析： 从左往右，a+b 被执行了 结果为真
                && 0 后，整个表达式的值确定了，一定为假，所以： a-b 没有执行
     
 * 总结：
     只有里面出现 假，则整体为假
     
======
* 逻辑或(||)：
 *姿势：
     表达式1 || 表达式2
     分析：
         只要表达式中 有表达式 成立 ，则整体成立
     
 * 逻辑或：
     表达式1 || 表达式2 || 表达式3 || 表达式4
     从左往右，只要有表达式成立，则不在往后执行  

=======
* 逻辑非：(!)
 * 姿势 ：
     ！表达式
     * 分析：
         表达式为真  ！表达式为假
         表达式为假  ！表达式为真
         
=======================
总结：
 逻辑&& 比 逻辑|| 的优先级 高一级 
         
====================================
真和假 (成立和不成立)
 ：真： 非0
 ：假： 0

=================================
关系运算符：(结果：真假)
 *  ><    >=   <=    ==   !=  
 
=================================
位移运算/移位：
 <<   >>
=====
<< : 左移
 姿势：
     某空间<< n ;
     解析：
         空出来的位置补0（删左补右）
 
 例子：
     int a = 10;
     a<< 2 ;  //  将a的值 取出来  放入 cpu寄存器中，左移2位 得到一个新的值
     
     a:  00000000 00000000 00000000 00001010
     cpu某个寄存器：     000000 00000000 00000000 0000101000     结果为40  
     
     
=======
>> :  右移：
 姿势：
     某空间 >>n
     解析：
         空出来的位置补？？？？（删右补左）
         1. 空出来的位置 补 符号位的值  算术右移
         2. 空出来的位置 补  0          逻辑右移
         
     例子：
         int a = 0x84451436;    //1000 顾a 是个负数
         a >>2 ;
         
练习：
 int a = 0xffffff48;
 a<< 4;     //   0xFFFFF480
 a >>4;        //     0xFFFFFFF4
 
==================================================
位运算：
 * 位与&
 * 位或|
 * 异或^
 * 取反~

====
位与&   ：  两个空间相同的位进行 & 运算 ，全部为1 结果才是1
     例子：
         int a = 66;
         int b = 77;
     
     a:     00000000 00000000 00000000 01000010
     b:    00000000 00000000 00000000 01001101     &
     ==================================================
         00000000 00000000 00000000 01000000            64
         
====
位或|    :     两个空间相同的位进行 | 运算 ，只要有1 结果就是1
     例子：
         int a = 66;
         int b = 77;
     
     a:     00000000 00000000 00000000 01000010
     b:    00000000 00000000 00000000 01001101     |
     ==================================================
         00000000 00000000 00000000 01001111            79    
         
         
====
异或^    ：    两个空间相同的位进行 ^ 运算 ，只要不相同，结果就是1
     例子：
         int a = 66;
         int b = 77;
     
     a:     00000000 00000000 00000000 01000010
     b:    00000000 00000000 00000000 01001101     ^
     ==================================================
         00000000 00000000 00000000 00001111             15       
         
====
取反~    :    单个空间每一个位上， 1变0  0变1
     
     例子：
         int a = 66;
     a:     00000000 00000000 00000000 01000010   ~
   ==========================================
         11111111 11111111 11111111 10111101    ===》 -67
         
     11111111 11111111 11111111 10111101
====》反码：
     11111111 11111111 11111111 10111100
   原码：
     10000000 00000000 00000000 01000011     -67
     
     
======
练习：
 int a = 0x12345678;
 将a 的 第 2 位 至 1            a = a|(1<<2)
 将a 的 第 3 位 至 0         a = a &    (~(1<<3))
 
 0001 0010 0011 0100 0101 0110 0111 1000
 0000 0000 0000 0000 0000 0000 0000 0100   |
 ===========================================
 0001 0010 0011 0100 0101 0110 0111 1100
 
 
 0001 0010 0011 0100 0101 0110 0111 1000
 1111 1111 1111 1111 1111 1111 1111 0111   &
 =============================================
 0001 0010 0011 0100 0101 0110 0111 0000   
 
 
=======================================================================
三目运算符：
 * 姿势：
     表达式1 ? 表达式2 ： 表达式3  
     *解析：
         表达式1 成立(非0) 那么就选择 表达式2 去执行
         表达式1 不成立(0) 那么就选择 表达式3 去执行
         
 例子：
     求两个数的大值和最小值：
     int a,b;
     int max = a >b ? a : b;
     int min = a >b ? b : a;

======================================================================
逗号运算符：
 * 逗号表达式 ：
     表达式1,表达式2,表达式3,表达式4...
     ====》
     从左往右依次执行 每一个 表达式 ，将 最后一个 表达式 的值 作为 整个 逗号表达式的值
     
 例子：    
     int a = 10;
     int b = 20;
     int c = 30;
     int d;
     d = (a++,b++,c++,a+b,a+c,++c,++b,++a);
     d: 11  12                  // 12
     a: 10  11  12           // 12
     b: 30  21  22  23          // 22
     c: 31  32                  // 32  
 
 解释：
     d = a++,b++,c++,a+b,a+c,++c,++b,++a;
     后面没有括号，不构成逗号运算
     d 其实 a++ 的值 ;

==========
sizeof :
 关键字
 求字节数：
 sizeof(最好放类型);
 sizeof(也可以放入变量名字);
 例子：
     sizeof(int); ===>4
     
short s = 10;
 sizeof(s); ===>sizeof(放入了变量); --->根据变量去寻找变量的类型，然后通过类型读出其字节数
 
==========
关键字：
 系统默认给定预留有实际意义的标识
 char short int long float double void sizeof
 unsigned signed return

优先级：(由高到低)
 括单术,移关位,逻三赋逗
 括： 括号： ()  []  ->.
 单： 单目： ++  --  ~   ！  (强转)   sizeof()  &  *
 术： 算术： +  -  *  /  %
 移： 移位：<<   >>
 关： 关系： ><  >= <=  ==  !=
 位：位运算： &  |  ^  
 逻： 逻辑： &&  ||
 三： 三目：  ?:
 赋： 赋值：  =  +=  -=  *=  /=  %= <<=  >>=  &&=  ||= ....
 逗： 逗号：  ,
 
     
例子：    
 int a = 10;
 int b = 20;
 
 a += a-b;    
 ====> a += -10;
          a = a+(-10);  a = 0;
         
         
==**********************************************************************
控制流：
 *控制程序运行的方向
 
 *分类：
     * 顺序结构
     * 分支结构
     * 循环结构
     
==========
顺序结构 ：
 程序自上而下，一行一行执行
 
===========================
分支结构：
 * if 语句
 * switch
 
===
if 语句：
 1.* 姿势1 ：
     if(表达式)
         有且仅有一条语句A;
 
     解析：
         表达式成立，则执行 语句A
         表达式不成立，则不执行语句A
 
 * 疑问：
     想在 if 后面跟多条语句？怎么办？？
     
 if 结合 代码块 ：
     if(表达式)
     {
         猥琐发育....
     }
     
     
***********************
代码块(程序块)：
 姿势：
 {
     为所欲为....;
 }
 
 整个代码块 相当于 一条语句 的 效果 .....

 2.* 姿势2 ：
     if(表达式)
         一条语句A;
     else
         一条语句B;
     
     解释：
         二选一的效果
         表达式成立，则执行语句A
         表达式不成立，则执行语句B
         
 ===》 if else 可以和 代码块结合
     if(表达式)
     {
         想干嘛就干嘛;
     }
     else
     {
         想怎么干就怎么干;
     }
     
 3* 姿势3：
     if(表达式1)
         语句A;
     else if(表达式2)
         语句B;
     else if (表达式3)
         语句C;
     .....
     else            // else 及  语句x;  可以省略
         语句X;
         
     分析：
         多选一的效果
         表达式1 成立，则执行语句A。然后结束了
         表达式1不成立，判断表达式2 ，如果表达式2成立，则执行语句B，然后结束
         表达式2 不成立，表达式2 也不成立，判断表达式3 ，如果表达式3成立，则执行语句C ，然后结束
         ........
     
     * 该姿势 还可以 与 代码块结合
     if(表达式1)
     {
         
     }
     else if(表达式2)
     {
         
     }
     else if (表达式3)
     {
         
     }
     .....
     else            // else 及  语句x;  可以省略
         语句X;

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧