C 语言-运算符(算术运算符,类型转换,赋值运算符,自增,自减,sizeof 运算符,逗号运算符,关系运算符,逻辑运算符,三目运算符)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    /*
     +  加法
     -  减法
     *  乘法
     /  除法
     %  取模（取余）
     */
    int result;
    result = 1 + 1;
    printf("加法结果：result = %in",result);
    result = 1 - 1;
    printf("减法结果：result = %in",result);
    result = 2 * 3;
    printf("乘法结果：result = %in",result);
    result = 10 / 2;
    printf("除法结果：result = %in",result); // result = 5
    result = 10 % 3;
    printf("取模结果：result = %in",result); // result = 1
  
    return 0;
}

    // 注意取模运算只能是整数取模不能是实数取模
    // result = 10.5 % 3; // 直接报错

    // 取模运算的正负性，取决于左边的操作数
    result = 10 % -3;
    printf("取模正负性结果：result = %in",result); // result = 1
    result = -10 % -3;
    printf("取模正负性结果：result = %in",result); // result = -1
    result = -10 % 3;
    printf("取模正负性结果：result = %in",result); // result = -1
    result = -0 % -3;
    printf("取模正负性结果：result = %in",result); // result = 0

 // 如果取模运算中，左边操作数小于右边操作数，那结果直接就是左边操作数，不会进行计算了
    result = 10 % 100;
    printf("取模结果：result = %in",result); // result = 10

 // 算术运算符的结合性
    result = 3 + 4 + 5 + 6;
    printf("result的值是%i",result);

 // 优先级+结合性
    result = 2 + 3 * 4 -4;
    printf("result的值是%in",result); // 先计算乘法，再从左至右的结合性计算

    // 系统自动进行的转换
    int number = 10.8;
    printf("number的值是%in",number); // number = 10,
    // 大类型的转换成小类型的，系统会自动进行转换，由大类型转换为小类型，丢失精度

    // 显式转换-只需要在值前面加（类型）
    int value = (int)10.8;
    printf("value的值是%in",value); // 10;
    // 大类型的转换成小类型的，系统会自动进行转换，由大类型转换为小类型，丢失精度

    // 在算术运算中，类型不一致时，系统会先将类型统一，统一成大类型进行计算
    int value2 = 10 + 9.9;
    // 10是int类型，9.9是double类型，int类型占4个字节，9.9占8个字节，所以先将int转为double类型
    // int value2 = 10.0 + 9.9
    // int value2 = 19.9
    // value2 是一个int类型，但是右边的19.9是double类型，这时候系统会做隐式转换，大类型转为小类型，既结果为19
    printf("value2的值是%in",value2); // 19;

    // 算术运算符的注意点-参与运算的操作数是什么类型，那么计算出来的结果就是什么类型
    int value3 = 1 / 2;
    printf("value3的值是%in",value3); // 打印出来的是0
    // 此时你会不会觉得是因为定义的变量是int类型导致的呢？那我就换成double类型的看看
    double value3 = 1 / 2;
    printf("value3的值是%lfn",value3); // 打印出来的是0.000000 此时还是0
    // 是因为右侧参与运算的都是整数，那么计算的结果肯定是整数


     // 那么如果需要打印出0.5该怎么办呢？
    double value4 = 1.0 / 2; // 此时一个double除以int类型，肯定是都先转换为doublee类型，计算出的结果就是double类型，i定义的变量也是double类型不需要转换所以打印出的是0.500000
    printf("value4的值是%.1lfn",value4);
    
    int value5 = 1.0 / 2;
    printf("value5的值是%in",value5); // 0

    // 新手注意饭的错误
    double value6 = (double)(1 / 2);
    // 右边先计算括号中的1 / 2，那么两个整数相除，结果肯定是整数，所以是0 ，由强转为double类型，为0.000000
    printf("value6的值是%lf",value6); // 0.000000

int main(int argc, const char * argv[]) {
    // 最简单的赋值运算符，将等号右边的值赋值给等号左边的变量
    // 赋值运算符的结合性是右结合性
    int number = 10;
    int a;
    int b;
    a = b = 5;
    printf("a的值是%i,b的值是%in",a,b);
    return 0;
}

    int a = 0;
    a += 3; // 这种是直接进行赋值，运算效率要好
    a = a +3; // 这一种是不是先计算再赋值给a
    printf("a的结果是%in",a);
// 复合赋值运算，会先进行右边的表达式得到的值在赋值给左边的变量

    int result = 10;
    result++;
    result++;
    printf("变量++，自增后的result值为：%in",result); // 12
    // 如果想让某一个数减1，可以使用变量--，--变量
    int value = 5;
    value--;
    printf("变量--，自增后的value值为：%in",value); // 4

// 第二种写法：++变量，--变量
    int result1 = 10;
    ++result1;
    printf("++变量，自增后的result1值为：%in",result1); // 11
    
    int result2 = 5;
    --result2;
    printf("++变量，自增后的result1值为：%in",result2); // 4

    // ++,-- 在变量前面和++，-- 在变量后面的区别
    // ++ , -- 在后面时，先参与运算然后再自增
    int a = 10;
    int b = a++;
    printf("a的值是%i，b的值是%in",a,b);// a的值是11，b的值是10 注意看b的值是10,而不是11,这里是a先赋值给b,然后再自增的
    
    // ++ --在变量之前时,是先自增再赋值
    int c = 10;
    int d = ++c;
    printf("c的值是%i，d的值是%in",c,d); // c的值是11,d的值是11 注意看这里d的值同样是11,所以c是先自增再赋值给d

    // 练习
    /*
    int a = 10;
    int b = (a++) + (++a);
    //  b = a++ ,此时a++的结果是11, 后面++a在a=11的基础上再自增,那么a的值就是12了,10+12
    //  a =12
    printf("b的值是%i,a的值是%in",b,a);
    */
    /*
    int a = 10;
    int b = (a++) + (a++);
    printf("b的值是%i,a的值是%in",b,a); // b = 10 + 11 , a = 12
    */
    /*
    int a = 10;
    int b = (++a) + (++a);
    printf("b的值是%i,a的值是%in",b,a); // b = 11 + 12 ,a = 12
    */
    /*
    int a = 10;
    int b = (++a) + (a++);
    printf("b的值是%i,a的值是%in",b,a); // b = 11 + 11, a = 12
    */
    int a = 10;
    int b = (a++) + (a--);
    printf("b的值是%i,a的值是%in",b,a); // b = 10 + 11 , a = 10

    // 自增的拆分
    int a = 10;
    int b = a++;
    // 拆分:
    // 1, int b = a;
    // 2, int a = a+1;
    printf("b的值是%i,a的值是%in",b,a); // b = 10,a = 11
    
    int c = 10;
    int d = ++c;
    // 拆分
    // 1,int c = c + 1;
    // 2,int d = c;
    printf("d的值是%i,c的值是%in",d,c);
    // 拆分之后,只是两个表达式的顺序反了. 如果有时确实难懂的话不妨拆分一下

    // 使用 sizeof 计算常量的内存字节
    int number = sizeof(10.9);
    printf("10.9的e内存字节是%in",number); // 8

    int a = 10;
    // int number = sizeof(a); // 只要是运算符就会有返回值
    int number = sizeof a; // 不加s括号e也可以
    printf("a的内存字节是%in",number);

    // 使用 sizeof 计算数据类型的内存字节
    int numChar = sizeof(char);
    printf("char 数据类型占用%i个字节n",numChar); // 1
    int numInt = sizeof(int);
    printf("int 数据类型占用%i个字节n",numInt); // 4
    int numDouble = sizeof(double);
    printf("double 数据类型占用%i个字节n",numDouble); // 8
    int numFloat = sizeof(float);
    printf("float 数据类型占用%i个字节n",numFloat); // 8

    // 逗号运算符,从左到右依次计算表达式的结果,只要是运算符就会有结果,逗号运算符也不例外
    int a = 10;
    int b = 5;
    int result;
    a = a + 10,b = b - 1,result = a + b;
    printf("a的值是%i,b的值是%i,result 的值是%in",a,b,result);

// 定一个一个变量 number 来接收逗号表达式的结果,每个表达式用括号括起来,整体再括起来,逗号表达式的结果是最后一个逗号表达式的结果
    int number =  ((a = a + 10),(b = b - 1),(result = a + b));
    printf("a 的值是%i,b 的值是%i,result 的值是%i,number 的值是%in",a,b,result,number);

    // > , < , >= , <= , == , !=
    int a = 10;
    int b = 5; // 怎么知道 a>b 呢? 任何的运算符都有结果
    int c = 20;
    int result = a > b;
    int result1 = a > c;
    printf("result的值是%in",result); // 1
    printf("result1的值是%in",result1); // 0

    // 关系运算符的优先级: > < >= <=的优先级大于 == , !=
    int a = 10;
    int b = 5;
    int result = 1 == a > b; // 先计算 a 是否大于 b,再拿这个结果与 1 是否相等,
    printf("result 的值是%i",result); // 1

    // 算术运算符的优先级大于关系运算符
    int result = 1 + 1 > 2+2;
    printf("result 的值是%in",result);  // 0,先计算 1+1,在计算 2+2,再拿 2>4?

    // 关系运算符的结合性是左结合性
    int result = 10 > 5 > 20;
    printf("result 的值是%in",result); // 0,先计算 10>5,再拿这个值与 20做比较

    // 如果优先级和结合性同时存在,那就先优先级,再结合性
    int result = 10 + 1 > 5 + 4 == 3 > 1;
    // 先计算 10+1,再计算 5+4,这两个算术运算符,得出 11 > 9 == 3>1
    // 再计算 11 > 9 ,和 3 > 1 这两个优先级比较高的比较运算符表达式,
    // 最后计算 1 == 1 等于的表达式
    printf("result 的值是%in",result); // 11 > 9 == 3 > 1 ---> 1 == 1 ---> 1

    int result1 = (10+1) > (5+4) == (3>1);
    printf("result1 的值是%in",result1); // h实际开发中为了阅读,还是加上括号

    // 逻辑与(一假则假)
    int result = 10 > 7 && 5 > 3; // 10>7为真,5>3 为真
    printf("result = %in",result); // 1
    int result1 = 10 > 90 && 8 >1; // 10 > 90为假
    printf("result1 = %in",result1); // 0

    // 逻辑或 (一真则真)
    int result = 10 > 8 || 9 > 7;
    printf("result = %in",result); // 都为真--真
    
    int result1 = 10 > 8 || 9 > 10;
    printf("result1 = %in",result1); // 一个为真--真
    
    int result2 = 10 > 11 || 9 > 10;
    printf("result2 = %in",result2); // 都为假--假
    
    int result3 = 10 > 11 || 9 > 8;  // 一个为真--真
    printf("result3 = %in",result3);

    // 逻辑非
    int result = ! 10; // 0
    int result1 = ! 0; // 1
    printf("result = %in",result);
    printf("result1 = %in",result1);

    int a = 10;
    int result = 10 < 8 && a++ > 5; // a = 10,result = 0
    // 由于 10 < 8 为假,所以后面的表达式就不会计算了,a++ 后,a 的值就没有自增
    int b = 20;
    int result1 = 10 > 8 && b++ >5; // 10 > 8 为真,后面的表达式继续计算,所以 b 的值是 21
    printf("a = %i,result = %in",a,result);
    printf("b = %i,result1 = %in",b,result1);

    int a = 10;
    int result = 10 > 8 || a++ > 5; // a = 10,result = 0
    // 由于 10 > 8 为真,所以后面的表达式就不会计算了,a++ 后,a 的值就没有自增
    int b = 20;
    int result1 = 10 < 8 || b++ >5; // 10 < 8 为假,后面的表达式继续计算,所以 b 的值是 21
    printf("a = %i,result = %in",a,result);
    printf("b = %i,result1 = %in",b,result1);

    int a = 10;
    if (a > 3 && a < 100){
        printf("a在 3-100 之间");
    } else{
        printf("a 不在 3-100 之间");
    }

    // 三目运算符
    int a = 10;
    int b = 20;
    int result = a > b;
    printf("result = %in",result);
    // 如果我想获取两个数之间的最大数呢?
    if (a>b){
        printf("a 和 b 之间最大数是%in",a);
    }else{
        printf("a 和 b 之间最大数是%in",b);
    }
    // 可是上面的办法太麻烦了,x要写这么多行代码
    int maxNum = a > b ? a:b; // 这句话的意思是,如果a> b,那就返回 a,如果 a 不大于 b 的话,那就返回 b
    printf("a 和 b 之间最大数是%in",maxNum);

    // 从控制台输入三个整数,返回最大的整数
    printf("请输入三个整数以逗号隔开,回车结束n");
    int num1,num2,num3;
    scanf("%i,%i,%i",&num1,&num2,&num3);
    int temp = num1 > num2 ? num1 : num2; // 比较 num1 和num2 中的最大值
    int maxNum = temp > num3 ? temp : num3; // 拿到 num1 和 num2 的最大值再与 num3 做比较,返回最大值
    printf("num1,num2,num3 之间的最大值是:%in",maxNum);
    
    int maxNum1 = (num1 > num2 ? num1 : num2) > num3 ? (num1 > num2 ? num1 : num2) : num3;
    // 不推荐这种写法是因为,问号之前计算了一次num1 和num2 的最大值,问号表达式之后又计算了一次,无疑消耗了性能
    printf("num1,num2,num3 之间的最大值是:%in",maxNum1);