1、算术运算符

#include <stdio.h>

int main()
{
    /*
     * 1.什么是算数运算符?
     * + - * / %
     */
    // 加法
    int result;
//    result = 1 + 1;
//    int num1 = 2;
//    int num2 = 2;
//    result = num1 + num2;
//    result = num1 + 1;

    // 减法
//    result = 1 - 1;

    // 乘法
//    result = 2 * 2;

    // 除法
//    result = 10 / 5;

    // 取余
    // 被除数 除数 商  余数
    // 10   ÷ 3 = 3   1
    result = 10 % 3;
    printf("result = %i\n", result);
    return 0;
}

#include <stdio.h>

int main()
{
    /*
     * 注意点:
     * 1.+ - * /
     * 在+ - * / 运算中, 如果整数和整数运算, 那么得到的结果一定是整数, 如果整数和小数运算, 那么得到的结果一定是小数
     * 2.%
     * 2.1在%运算中, 不能出现小数(%运算只能计算整数)
     * 2.2在%运算中, 如果被除数小于除数, 那么结果就是被除数
     * 2.3在%运算中, 如果被除数是0, 那么结果就是0
     * 2.4在%运算中, 结果的正负性, 取决于被除数的正负性(被除数如果正数, 那么结果就是正数, 被除数如果是负数, 那么结果就是负数)
     */
//    double result;
//    result = 10 / 3; // 3
//    result = 10 / 3.0; // 3.333333
//    result = 10.0 / 3; // 3.333333
//    result = 10.0 / 3.0; // 3.333333
//    printf("result = %lf\n", result);
    int result;
//    result = 10 % 3;
//    result = 10 % 3.0;
//    result = 10.0 % 3;
//    result = 2 % 3;
//    result = 0 % 3;
//    result = 10 % -3; // 1
    result = -10 % 3; // -1
    printf("result = %i\n", result);
    return 0;
}

#include <stdio.h>

int main()
{
    // 1.C语言中只有相同类型数据才能进行运算
    // 2.C语言只要发现参与运算的变量或者常量不是同一类型, 就会自动将小类型转换为大类型
    // 3.参与运算的是什么类型, 得到的结果就是什么类型
    int a = 10;
    double b = 3.14;
    // 此处a和b类型不同, 编译器会自动将小类型转换为大类型
    // a是int占用4个字节, b是double占用8个字节, 所以a是小类型
    // 运算时会将a转换为double再运算
    // 相当于   res = 10 + 3.14; --> res = 10.0 + 3.4
    double res = a + b;
    // 参与运算的是什么类型, 结果就是什么类型, 参与运算的都是double,所以结果是double
    printf("res = %lf\n", res);
    // 以上这种规则我们称之为: 运算转换(自动类型转换)


    int c = 10;
    double d = c;
    // 在赋值时会自动将等号右边的类型转换为等号左边的类型
    // 以上这种规则我们称之为: 赋值转换(自动类型转换)

    double e = 3.14;
    int f = (double)e;
    // 只要在变量或者常量前面加上(数据类型), 就会强制将变量或者常量转换为指定类型
    // 以上这种规则我们称之为: 强制类型转换
    return 0;
}

2、赋值运算符

#include <stdio.h>

int main()
{
    /*
     * 赋值运算符
     * 1.简单赋值运算符
     * =
     * 2.复杂赋值运算符
     * += -= *= /= %=
     */
    // 1.简单赋值运算符
    // 作用: 将等号右边的值赋值给等号左边的变量
    // 结合性: 右结合性
    int num;
    num = 666;
    printf("num = %i\n", num);

    // 2.复杂赋值运算符
    int value = 10;
//    value += 5; // value = value + 5; value = 10 + 5;
//    value -= 5; // value = value - 5; value = 10 - 5;
    value *= 2; // value = value * 2; value = 10 * 2;
    printf("value = %i\n", value);
    return 0;
}

#include <stdio.h>

int main()
{
    /*
     * 1.赋值运算符结合性
     * 右结合性
     * 2.优先级
     * 赋值运算符的优先级 低于 算数运算符
     */
//    int res = 10;
//    res += 10 - 5; // res = res + (10 - 5); res = 10 + (10 - 5);
//    printf("res = %i\n", res);

    int num = 10;
    num += 5; // num = num + 5;

    int value = 10;
    value += 2 + 2; // value = value + (2 + 2);


    int temp = 2 + 2;
    printf("temp = %i\n", temp);
    return 0;
}

3、自增自减运算符

#include <stdio.h>

int main()
{
    // 要求给一个变量+5
    int num = 10;
//    num = num + 5;
//    num += 5;

    // 要求给一个变量+1
//    num = num + 1;
//    num += 1;


    /*
     * 自增作用: 快速的给一个变量+1
     * 格式: ++
     * 只要在一个变量的后面或者前面写上++, 就代表要给这个变量+1
     * 自减作用: 快速的给一个变量-1
     * 格式: --
     * 只要在一个变量的后面或者前面写上--, 就代表要给这个变量-1
     */
//    num++;
//    ++num;
//    num--;
    --num;
    printf("num = %i\n", num);
    return 0;
}

#include <stdio.h>

int main()
{
    /*
     * 自增和自减可以写在变量前面, 也可以写在变量后面
     * 写在前面和后面的区别:
     * 如果自增和自减写在变量前面, 代表先自增和自减再参与其它运算
     * 如果自增和自减写在变量后面, 代表先参与其它运算再自增和自减
     */
    /*
    int num = 10;
//    int res = 10 + num++; // int res = 10 + 10; num++
    int res = 10 + num--; // int res = 10 + 10; num--
    printf("res = %i\n", res); // 20 20
    printf("num = %i\n", num); // 11 9
    */

    int num = 10;
//    int res = 10 + ++num; // ++num; int res = 10 + 11
    int res = 10 + --num; // --num; int res = 10 + 9
    printf("res = %i\n", res); // 21 19
    printf("num = %i\n", num); // 11 9

    return 0;
}

#include <stdio.h>

int main()
{
    /*
     * 注意点:
     * 1.自增和自减只能用于变量, 不能用于常量和表达式
     * 2.在企业开发中自增和自减最好单独出现
     * 3.同一个表达式中同一个变量同时自增或自减, 这种格式的表达式在C语言中没有规定如何运算
     * 所以结果是不确定的, 在不同的编译器下运行的结果不同
     */
    /*
    int num = 10;
    num++;
    num--;

//    10++; // 会报错

    int a, b;
    a = 10;
    b = 20;
    (a + b)++;
    */

    /*
    int num = 10;
//    int res = 10 + num++; // int res = 10 + 10; num++;
//    int res = 10 + num;
//    num++;
//    int value = num++;
    int value = num;
    num++;
    printf("value = %i\n", value); // 10
    printf("num = %i\n", num); // 11
    */

    int num = 10;
    int res = ++num + ++num; // 千万不要这样写
    printf("res = %i\n", res);

    return 0;
}

4、sizeof运算符

#include <stdio.h>

int main()
{
    /*
     * sizeof运算符
     * 格式:
     * 第一种格式:
     * sizeof(变量/常量/数据类型);
     * 第二种格式:
     * sizeof 变量/常量
     * 作用:
     * sizeof运算符是专门用于计算变量/常量/数据类型占用的存储空间的
     */
    int num = 10; // 4个字节
    // 计算变量
//    int res = sizeof(num);
//    int res = sizeof num;
    // 计算常量
//    int res = sizeof(3.14);
//    int res = sizeof 3.14;
    // 计算数据类型
//    int res = sizeof(char);
//    int res = sizeof char; // 会报错, 不能省略()
    printf("res = %i\n", res);
    return 0;
}

#include <stdio.h>

int main()
{
    /*
     * 1.sizeof是一个运算符, 不是一个函数
     * 2.既然sizeof是一个运算符, 所以它也有优先级
     * sizeof运算符的优先级高于算数运算符
     */
    //               double int           double double          double
//    int res = sizeof(3.14 + 1); // sizeof(3.14 + 1.0) --> sizeof(4.14)
//    printf("res = %i\n", res);

    // 由于sizeof的优先级高于算数运算符
    // 所以会先计算 sizeof 3.14 --> 8
    // 然后再利用计算结果和1相加  8 + 1 == 9
//    int res = sizeof 3.14 + 1;
    int res = sizeof(3.14) + 1;
    printf("res = %i\n", res);
    return 0;
}

5、逗号运算符

#include <stdio.h>

int main()
{
    /*
     * 1.逗号在C语言中也是一个运算符
     * 2.作用: 一般用于简化代码
     * 3.注意点: 既然逗号是一个运算符, 所有的运算符都有结果
     * 逗号运算符的运算结果是最后一个表达式的值
     * 逗号在运算符的结核性是左结合
     */
    /*
    // 应用场景
    // 同时定义多个变量
    int a, b;
    // 同时给多个变量赋值
    a = 10, b = 20;
    */
    // 面试
    int a, b, c;
    a = 10, b = 20, c = 30;
    // int res = ((10 + 20), (10 + 30));
    int res = ((a + b), (a + c));
    printf("res = %i\n", res);

    return 0;
}

6、关系运算符

#include <stdio.h>

int main()
{
    /*
     * 关系运算符
     * > >= < <= == !=
     * 返回值: 要么是0, 要么是1
     * 0 代表关系不成立 1代表关系成立
     * 在C语言中非0即真
     * 只有数值是0 才代表是假, 其它的都是真 -1 1 666 999
     *
     * 关系运算符的结核性
     * 左结合性
     *
     * 优先级
     * > >= < <= 优先级高于 == !=
     * 如果优先级和结合性同时存在的时, 先优先级后结合性
     */
    /*
    int a, b;
    a = 10, b = 5;
//    int res = a > b;
//    int res = a < b;
//    int res = 10 == 10;
    int res = 11 != 10;
    printf("res = %i\n", res);
    */
    // int res = (10 > 5) > 3
    // int res = (1) > 3
//    int res = 10 > 5 > 3;

    // int res = 10 == (10 > 9)
    // int res = 10 == (1)
//    int res = 10 == 10 > 9;
//    printf("res = %i\n", res);

    // 结论: 不要使用关系运算符判断区间
    // int res = (20 >= 15) >= 10;
    // int res = (1) >= 10;
    int x = 15;
    int res = 20 >= x >= 10;

    return 0;
}

7、逻辑运算符

#include <stdio.h>

int main()
{
    /*
     * 逻辑运算符
     * 1.逻辑与 &&
     * 格式: 表达式 && 表达式
     * 结果: 和关系运算符一样 0 和 1
     * 规则: 一假则假
     * 2.逻辑或 ||
     * 格式: 表达式 || 表达式
     * 结果: 和关系运算符一样 0 和 1
     * 规则: 一真则真
     * 3.逻辑非 !
     * 格式: !表达式
     * 结果: 和关系运算符一样 0 和 1
     * 规则: 真变假假变真
     */
    /*
    //         表达式1      表达式2
    //         1(真)         1(真)
    //        10 > 5 并且 20 > 19
//    int res = (10 > 5) && (20 > 19);
    //         0(假)         1(真)
//    int res = (10 > 11) && (20 > 19);
    //         1(真)         0(假)
    int res = (10 > 9) && (20 > 29);
    printf("res = %i\n", res); // 1 0
    */

    /*
    //          1(真)  ||   1(真)
//    int res = (10 > 9) || (20 > 8);
    //          0(假)  ||   1(真)
//    int res = (10 > 11) || (20 > 8);
    //          1(真)  ||   0(假)
    int res = (10 > 1) || (20 > 28);
    printf("res = %i\n", res);
    */

    //        !1(真)
//    int res = !(10 > 9);
    //        !0(假)
    int res = !(10 > 19);
    printf("res = %i\n", res);
    return 0;
}

#include <stdio.h>

int main()
{
    /*
     * 1.逻辑与 &&
     * 结合性: 左结合性
     * 特点: 逻辑短路, 只要第一个表达式为假, 那么第二个表达式就不会计算
     * 因为规则是: 一假则假
     * 2.逻辑或 ||
     * 结合性: 左结合性
     * 特点: 逻辑短路, 只要第一个表达式为真, 那么第二个表达式就不会计算
     * 3.逻辑 !
     * 结合性: 右结合性
     * 特点: 可以连续飞飞飞飞
     */

    /*
    int a = 10; // 11
    //          1(真)  &&  1(真)
//    int res = (10 > 9) && (++a > 5);
    //          0(假)   &&
    // 原因: 无论第二个表达式的结果是真是假, 整个表达式的结果都是假, 所以再计算第二个表达式没有任何意义, 所以只要第一个表达式为假, 第二个表达式就不会运算
    int res = (10 > 19) && (++a > 5);
    printf("res = %i\n", res); // 1(真)   0(假)
    printf("a = %i\n", a); // 11   10
    */

    /*
    int a = 10; // 11
    //          1(真)  ||
    // 原因: 无论第二个表达式的结果是真是假, 整个表达式的结果都是真, 所以再甲酸第二个表达式没有任何意义, 所以只要第一个表达式为真, 第二个表达式不会运算
//    int res = (10 > 9) || (++a > 5);
    //          0(假)   ||     1(真)
    int res = (10 > 19) || (++a > 5);
    printf("res = %i\n", res); // 1(真) 1(真)
    printf("a = %i\n", a); // 10  11
    */

    /*
    //        (!(!(!(10 > 9))))
    //        (!(!(!1)))
    //        (!(!0))
    //        (!1)
    int res = !!!(10 > 9);
    printf("res = %i\n", res);
    */
    // 注意点:
//    int res = !666;
//    int res = !0;

//    int res = 666 && 888;
    int res = 666 && 0;
     printf("res = %i\n", res); // 0 1
    return 0;
}

8、三目运算符

#include <stdio.h>

int main()
{
    /*
     * 三目运算符
     * 格式: 表达式 ? 结果A : 结果B;
     * 结果:
     * 表达式的值为真, 那么就返回结果A
     * 表达式的值为假, 那么就返回结果B
     * 注意点:
     * 三目运算符中 ?:不能分开使用
     * 三目运算符的优先级低于算数运算符
     */

    /*
    int a, b;
    a = 10, b = 15;
    //          1(真)
    //          0(假)
    int res = a > b ? a : b;
    printf("res = %i\n", res);
    */
    //          15   >   10 ? 666 : 888
    //          1(真) ? 666 : 888
//    int res = 10 + 5 > 5 + 5 ? 666 : 888;
//    int res = (10 + 5 > 5 + 5) ? 666 : 888;
    int temp1 = 10 + 5;
    int temp2 = 5 + 5;
    int res = (temp1 > temp2) ? 666 : 888;
     printf("res = %i\n", res);

     // 作业:
     // 1.从键盘输入一个整数, 判断这个整数时候是100~200之间的一个数
     // 2.从键盘输入两个整数, 找出最大值, 然后输出最大值
     // 3.从键盘输入三个整数, 找出最大值, 然后输出最大值
     // 提示: 先写注释, 再写代码
     // 例如:
     // 1.定义变量保存用户输入的数据
     // 2.提示用户如何输入数据
     // 3.接收用户输入的数据
     // 4.利用逻辑运算符判断是否在某个区间内
     // 5.在区间内输出YES, 不在区间内输出NO
    return 0;
}

#include <stdio.h>

int main()
{
    /*
     // 1.从键盘输入一个整数, 判断这个整数是否是100~200之间的一个数
     // 2.从键盘输入两个整数, 找出最大值, 然后输出最大值
     // 3.从键盘输入三个整数, 找出最大值, 然后输出最大值
     */

    // 1.定义变量保存用户输入的数据
    int num = -1;
    // 2.提醒用户如何输入
    printf("请输入一个整数, 以回车结束\n");
    // 3.接收用户输入的数据
    scanf("%i", &num);
    // 4.判断是否是100~200之间的数
    int res = num >= 100 && num <= 200;
    // 5.输出判断的结果
    res ? printf("是100~200之间的数"): printf("不是100~200之间的数");

    return 0;
}

#include <stdio.h>

int main()
{
    // 从键盘输入两个整数, 找出最大值, 然后输出最大值

    // 1.定义两个变量保存用户输入的数据
    int a, b;
    a = -1, b = -1;
    // 2.提醒用户如何输入数据
    printf("请输入两个整数, 用逗号隔开, 以回车结束\n");
    // 3.接收用户输入的数据
    scanf("%i,%i", &a, &b);
    // 4.判断两个整数谁比较大, 拿到比较大的那个整数
    int max = (a > b) ? a : b;
    // 5.输出最大值
    printf("max = %i\n", max);
    return 0;
}

#include <stdio.h>

int main()
{
    // 从键盘输入三个整数, 找出最大值, 然后输出最大值
    // 1.定义三个变量用于保存用户输入的数据
    int a, b, c;
    a = -1, b = -1, c = -1;
    // 2.提示用户如何输入数据
    printf("请输入三个整数, 以逗号隔开, 以回车结束\n");
    // 3.接收用户输入的数据
    scanf("%i,%i,%i", &a, &b, &c);
    // 4.先比较某两个变量, 取出最大值
    int max = (a > b) ? a : b;
    // 5.利用刚才取出的最大值和剩余的变量比较
    max = (max > c) ? max : c;
    // 6.输出结果
    printf("max = %i\n", max);

    int min; // 定义变量, 会开辟存储空间
    min; // 使用变量
    return 0;
}