二、C_base——数据类型/运算符

【1】数据类型

1--- 定义变量

        数据类型 变量名 = 初始值；
        数据类型 变量名；


        变量名：由数字、字母、下划线组成，开头不能是数字

2--- bool
        #include <stdbool.h>
        bool a = 123；
        printf（“a = %d\n”,a）;       



3--- char
        char a = 'A';           //占1个字节，8位
        printf（“a = %c\n”,a）;   --> A   
        printf（“a = %d\n”,a）;   --> 65
        signed char     :-128~127
        unsigned char    :0~255



4--- int
        int 占4字节，32位
        signed int  ：-2147483648 ~ 2147483647
        unsigned int    ：0~ 4294967295



        short 占2字节，16位
        signed short    ：-32768 ~ 32767
        unsigned short  ：0 ~ 65535


        long 占4字节



5--- float

        float   占4字节
        double  占8字节

【2】数据的存储

    正数：unsigned  char a = 12    
         0000  1100 源码、反码、补码相同

    负数：signed   char a = -12
        1000  1100   源码（最高位是符号位）
        1111  0011   反码（符号位不变，其它位取反）
        1111  0100   补码（反码+1）


unsigned char b = -1;                   signed char c = 129;
存储（看数值）：                              存储（看数值）：

源码：  1000 0001    --> -1             源码： 1000 0001   --> 129
反码：  1111 1110                          
补码：  1111 1111                 读取（signed）： 

读取（unsigned）：                    补码：  1000 0001    
                                    反码：  1000 000
补码：  1111 1111    --> 255         源码：  1111 1111   --> -127

【3】全局变量和局部变量

     全局变量，不初始化时为0。   
     局部变量，不初始化时为随机值。
     全局变量和局部变量名字相重时默认使用局部的变量。

【4】常量

    只读的数据。

    字符常量  ：‘A’  ‘*’  ‘！’ ‘\n’
    整数常量  ： 12    012    0x12
    浮点型常量： 12.34
    指数常量  ： 1.2e-3
    字符串常量： "world"      //以‘\0’作为结束标志

    "world"     // w o r l d \0
    ‘w’         //一个字符 
    "w"         //字符串： 'w' + '\0'

【5】运算符

1--- 算术运算符
        +  -  *  /  %（参与运算的只能是整数）

        ++   自增运算符；++在变量名的后面：则先参与其他所有运算，再执行自增
        --   自建运算符；--在变量名的后面：则先参与其他所有运算，再执行自减


2--- 关系运算符
        运算结果只有两种情况：真1  假0

        <   <=    >    >=   ==   !=

3--- 逻辑运算
        运算结果只有两种情况：真1  假0

        &&  ：一假则假   
        ||  ：一真则真
        !   ：真变假，假变真

        短路原则：当一个表达式可以决定整个运算的结果，其它运算不执行      

4--- 位运算

        ~   ：位运算取反 
        ^   ：异或，相同为0，不同为1
        &   ：位与
        |   ：位或

        a>>n ： a / 2^n;
        a<<n ： a * 2^n;


5--- 复合运算符

        =  +=  -=   *=   /=  %=
        &=  |=  ^=  <<=  >>=

6--- 条件运算符
        <表达式1>  ?  <表达式2>  :  <表达式3>
        先判断表达式1，为真执行表达式2， 为假执行表达式3

【6】运算优先级

    （）
     ++  --

     *  /  %
     +   -

    <<   >>

    关系运算

    位运算符（&  ^  |）

    逻辑运算

    赋值运算,复合运算符

      ， 

源码及注释：

1、1_bool.c

#include <stdio.h>
#include <stdbool.h>

//数据类型 变量名 = 初始值；

int main(int argc, const char *argv[])
{
    bool  a = 123;
    printf("a = %d\n", a);  //printf：用于向终端输出指定格式的数据
                            //双引号里的数据原样输出，除%形式以外
    a = 0;
    printf("a = %d\n", a);  //printf：用于向终端输出指定格式的数据


    return 0;
}

2、2_char.c

#include <stdio.h>

//数据类型 变量名 = 初始值；

int main(int argc, const char *argv[])
{
    //字符类型
    char a = "";                    //占一个字节，8位
    printf("a = %c\n",a);           //%d：整型     %c ：字符类型


    //0 ~ 255
    unsigned char b = -1;
    printf("b = %d\n",b);

    //-128 ~ 127
    signed char c = 129;
    printf("c = %d\n",c);

    return 0;
}

3、3_int.c

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int a = 10;                     //占4字节，32位
    printf("a = %d\n",a);

    short b = 30;                   //占2字节，16位
    printf("b = %d\n",b);

    long c = 40;                    //占4字节（在32位操作系统下）
    printf("c = %ld\n",c);  //%d 整型   %c 字符类型   %ld long

    return 0;
}

4、4_float.c

#include <stdio.h>

int c;                              //全局变量，不初始化时为0

int main(int argc, const char *argv[])
{
    float a = 12.34;
    printf("a = %f\n",a);

    double b = 34.56;
    printf("b = %f\n",b);

    int c = 23;             //局部变量，不初始化时为随机值
    //全局变量和局部变量名字相重时默认使用局部的变量
    printf("c = %d\n",c); 
    int i,j,k;

    return 0;
}

5、5_count.c

#include <stdio.h>

#define N 30                //宏定义：给一个常量命名

int main(int argc, const char *argv[])
{
    int a = 12;             //= ：赋值运算符，从右向左赋值
    a = 012;                //1*8+2
    a = 0x12;               //1*16+2
    printf("a = %d\n",a);

    char c = 'Y';
    printf("c = %c\n",c);


    float f = 12e-3;        //12 * 10^-3
    f = 0.012e+3;           //12 * 10^+3
    printf("f = %f\n",f);


    printf("s = %s\n", "hello");    //'h'  'e'  'l'  'l'  'o'  '\0'
                                    //字符串都是以‘\0’作为结束标志的
    int i = N;
    printf("i = %d\n",i);
    return 0;
}

6、6_expr+.c

#include <stdio.h>

// +  -  *  /  %
int main(int argc, const char *argv[])
{
    int a = 13, b = 9;
    int ret = 0;
//参与运算的数据全是整型数据，结果一定取整
    ret = a/5;                  
    printf("ret = %d\n",ret);

    ret = a%5;                  //% ：参与运算的只能是整数
    printf("ret = %d\n",ret);


    int c = 537;
    int ge,shi,bai;

    ge  = c % 10;
    shi = c % 100 / 10;
    bai = c / 100;
    printf("ge = %d  shi = %d  bai = %d\n",ge, shi, bai);

    /*
     *   shi = c / 10 % 10;
     *   shi = c % 100 / 10;
     */

    return 0;
}

7、7_expr++.c

#include <stdio.h>

//自增运算符  ++
//自减运算符  --

int main(int argc, const char *argv[])
{
    int a = 5;
    int b = 6;
//++在变量名的后面：则先参与其他所有运算，再执行自增
    printf("a = %d\n",a++);  
    printf("a = %d\n",a); 

    printf("b = %d\n",b--);  
    printf("b = %d\n",b); 

/*  
    printf("a = %d\n",++a);         // a = a + 1;
    printf("b = %d\n",--b);         // b = b - 1;
*/

    return 0;
}

8、8_expr_relation.c

#include <stdio.h>

//关系运算的结果只有两个值： 真1  假0
//<   <=   >   >=   ==   !=


int main(int argc, const char *argv[])
{
    int a = 0, b = 7;
    int ret = 0;

    ret = a == b;
    printf("ret = %d\n",ret);
    ret = a <= b;
    printf("ret = %d\n",ret);

    //表达式为真执行1, 为假执行2
    if(a<0) 
    {
        //执行体1 
        printf("负数\n");
    }
    else
    {
        //执行体2
        printf("非负数\n");
    }

    return 0;
}

9、9_expr_logic.c

#include <stdio.h>

//逻辑运算的运算结果只有两个值： 真1  假0
//&&   ||    !

int main(int argc, const char *argv[])
{
    int a = 8, b = 10;
    int ret = 0;

    ret = a && b;               //&&  ：一假则假
    printf("&& = %d\n",ret);

    ret = a || b;               //||  ：一真则真
    printf("|| = %d\n",ret);

    ret = ! b;                  // !  ：真变假，假变真
    printf("!  = %d\n",ret);

    //判断a的取值区间，是否实在0 ～ b之间
    if(0 < a  &&  a < b)
    {
        printf("真\n");
    }
    else
    {
        printf("假\n");
    }

    return 0;
}

10、5_bit.c

#include <stdio.h>

//位运算
// &  |   ^   ~  

int main(int argc, const char *argv[])
{
    int a = 16, b = 5;          //a:  0110
    int ret = 0;                //b:  0101
                                //^:  0011
    ret = a & b;
    printf("& = %d\n",ret);

    ret = a | b;
    printf("| = %d\n",ret);

    ret = a ^ b;                //异或：相同为0 不同为1
    printf("^ = %d\n",ret);

    ret = ~b;              
    printf("~ = %d\n",ret);    
    /*   存（数据）  0 0000 0101         ---> 5
     *   ～          1 1111 1010         ---> ~5
     *   读（signed）1 1111 1010   补码
     *               1 1111 1001   反码
     *               1 0000 0110   源码  ---> -6
     */


    ret = a << 2;               //a<<n   <==>  ret = a * 2^n
    printf("<<= %d\n",ret);     

    ret = a >> 3;               //a>>n   <==>  ret = a / 2^n
    printf(">>= %d\n",ret);     




    return 0;
}

11、11_expr=.c

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int a = 5, b = 6;

    //让a与b的数据交换,不使用中间变量
    a ^= b;
    b ^= a;
    a ^= b;
    printf("a = %d\n",a);
    printf("b = %d\n",b);

#if 0
     a   0101
     b   0110
     ________
     a   0011
     b   0110
     ________
     b   0101     -->  5
     a   0011
     ________
     a   0110     -->  6
#endif

/*  
    int t;
    t = a;
    a = b;
    b = t;
*/

    int i = 3, j = 6;
    i += j;             // i = i + j;
    printf("i = %d\n",i);

    return 0;
}

12、12_expr.c

#include <stdio.h>

//sizeof():用于求一个数据开辟空间的大小
//sizeof（类型名）；  sizeof（变量）

int main(int argc, const char *argv[])
{
    int a = -2;
    a > 0 ? printf("真\n") : printf("假\n");

    int ret = a > 0 ? 7 : 0;
    printf("ret = %d\n",ret);

//逗号运算符优先级最低，运算的结果由最后一个表达式决定
    ret = (a, 34, a, 17);           
    printf("ret = %d\n",ret);

    float b = 12.34;
    char c = 'G';
    printf("size = %d\n",sizeof(a));
    printf("size = %d\n",sizeof(c));
    printf("size = %d\n",sizeof(short));
    printf("size = %d\n",sizeof(double));


    //(类型)   强制类型转换
    printf("add = %d\n",(int)(12+b));

    return 0;
}