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;
}
