C4

#include <stdio.h>

int main(int argc, const char * argv[]) {

    // int 占用4个字节 double 占用8个字节

    // 只是相同类型的数据才能进行运算, 隐式类型转换 将小类型转换为大类型, 然后再进行运算

    // 在赋值的时候系统又给我们进行了一次隐式类型转换

    // 发现, 如果在隐式类型转换的时候, 将大类型转换为小类型会丢失精度

    int result = 10.9;

    printf("result = %d\n", result);

    // 强制类型转换格式: (类型)被强制类型转换的数据

    int result2 = (int)10.9;

    printf("result2 = %i", result2);

    // 自动类型提升

    // 自动类型的提升, 将参与运算的数据都转换为同一类型后再运算

    // 会自动将小的数据类型提升为大的数据类型

    int result3 =  + 9.9; // 1.0 + 9.9 = 10.9

    // 在算术运算中, 参与运算的是什么类型, 计算出来就是什么类型

    double result = 1.0 / ; // 1.0 / 2.0 --> 0.5

    double result = (double) / ;// 1.0 / 2.0 --> 0.5

    double result = (double)( / ); // (double)(0) --> 0.0

    printf("result = %lf\n", result);

    // 算术运算符的结合性, 左结合, 从左至右的计算

    // 算术运算符的优先级 * / % 大于 + -

    // 如果优先级和结合同时存在, 那么先优先级再结核性

    int result =  +  *  + ;

    printf("result = %i\n", result);

    return ;

}

void test()

{

    /*

     + 加法

     - 减法

     * 乘法

     / 除法

     % 取模(取余)

     */

    // 1.定义变量保存计算结果

    int result;

    // 2.开始计算

    result =  + ;

    result =  - ;

    result =  * ;

    result =  / ;

    // 注意: 取模运算只能用于整数

    //    result = 10 % 3;

    //    result = 12 % 5;

    //    result = 10.0 % 3.0;

    // 取模运算的正负性取决于左边的操作数, 如果左边为负数, 那么结果就是负数

    //    result = 10 % -3;

    //    result = -10 % -3;

    //    result = -10 % 3;

    // 如果取模运算的左边小于右边, 那么结果就是左边

    result =  % ;

    // 3.验证计算结果

    printf("result = %i", result);

}

//

//  main.c

//  逗号运算符

//

//  Created by xiaomage on 15/6/4.

//  Copyright (c) 2015年 xiaomage. All rights reserved.

//

#include <stdio.h>

int main(int argc, const char * argv[]) {

    int a = ;

    int b = ;

    int result;

    // 结合性 从左至右

    // a = 15, b = 6, result = 15 + 6 = 21

    a = a + , b = b +  , result = a + b;

    printf("a = %i, b = %i, result = %i\n", a, b, result);

    // 只要是运算符那么一定会有运算结果, 逗号运算符也不例外.

    // 逗号运算符的结果是 最后一个表达式的结果

    int a = ;

    int b = ;

    //   6       a = 10 + 5 = 15 b = 5 + 1 = 6

    int result = ((a = a + ), (b = b + )); // 仅仅作为了解,逗号表达式返回最后一个的值

    printf("a = %i, b = %i, result = %i\n", a, b, result);//15,6,6

    return ;

}

//

//  main.c

//  赋值运算符

//

//  Created by xiaomage on 15/6/4.

//  Copyright (c) 2015年 xiaomage. All rights reserved.

//

#include <stdio.h>

int main(int argc, const char * argv[]) {

    // 最简单的赋值运算符

    // 赋值运算符的结合性: 从右至左

//    int result = 10;

    // 复合赋值运算符: += -= *= /= %=

    int result = ;

//    result = result + 5;// result = 10 + 5; result = 15

//    result += 5; // 相当于 result = result + 5;

    result -= ; // 相当于result = result - 5;

    printf("result = %i\n", result);

    return ;

}

#include <stdio.h>

int main(int argc, const char * argv[]) {

    /*

     关系运算符:

     >

     <

     >=

     <=

     ==

     !=

     关系运算符的返回值只有两种, 要么真, 要么假. 1(真)和0(假)

     */

    int a = ;

    int b = ;

    int result = a > b;// 吗? 大于, 真, 非0即真.

    printf("result = %i\n", result);

    int a = ;

    int b = ;

    int result = a != b;

    printf("result = %i\n", result);

    // 关系运算符注意点

    // 关系运算符也有优先级. > < >= <= 优先级大于 == !=

    //             1 == 1

    int result =  ==  > ;

    // 算术运算符的优先级 大于 关系运算符

    //             2 <  4

    int result =  +  <  + ;

    // 关系运算符的结合型: 从左至右

    //              1 > 1

    int result =  >  > ;

    // 如果优先级和结合性同时存在, 先优先级再结核性

    //              11 > 9 == 3 > 1

    //               1 == 3 > 1

    //               1 == 1

    int result =  +  >  +  ==  > ;

    printf("result = %i\n", result);

    // 练习

//    int result = 3 > 4 + 7; // 3 > 11 = 0

//    int result = (3>4) + 7; // 0 + 7

    //           5 != 4 + 14 > 3 == 10

    //           5 != 18 > 3 == 10

    //           5 != 1 == 10

    //           1 == 10

    int result =  !=  +  *  >  == ;

    printf("result = %i\n", result);

    return ;

}

//

//  main.c

//  自增自减

//

//  Created by xiaomage on 15/6/4.

//  Copyright (c) 2015年 xiaomage. All rights reserved.

//

#include <stdio.h>

int main(int argc, const char * argv[]) {

    int result = ;

//    result = result + 5;

//    result += 5;

//    result = result + 1;

//    result += 1;

    // 自增: 如果想让某一个数加1可以使用自增

//    result++;

//    result++;

//    result = result - 1;

//    result -= 1;

    // 自减: 如果想让某一个数减1可以使用自减

//    result--;

    // 自增的两种写法

//    result++;

//    ++result;

    // 自减的两种写法

    result--;

    --result;

     printf("result = %i\n", result);

    // 自增自减写在前面和后面的区别

    // 如果++写在变量的前面, 那么会先将变量自增再用自增之后的结果参与运算

    // 如果++写在变量的后面, 那么会先将变量的值参与运算再将变量自增

    // 总结一句话: ++在前, 先自增再运算, ++在后, 先运算再自增

    int a = ;

//    int b = a++;// b = 10, a = 11

//    int b = ++a;// a = 11,  b = 11;

//    int b = a--;// b = 10, a = 9;

    int b = --a; // a = 9, b = 9;

    printf("a = %i , b = %i\n", a, b);

    // 无论++在前还是在后, 最终都会自增一次

    int a = ;

    //       10   +  12

//    int b = (a++) + (++a);

    // a = 12

    // b = 22

    //        10  +   11

//    int b = (a++) + (a++);

    // a = 12

    // b = 21

//           11   +   12

    int b = (++a) + (++a);

    // a = 12

    // b = 23

    printf("a = %i, b = %i\n", a, b);

//    5++;

    double doubleValue = 10.9;

    doubleValue++;

    printf("%f", doubleValue);

    int a = ;

//    int b = a++;

    // b = a; a = a + 1;

    int b = ++a;

    // a = a + 1; b = a;

    printf("a = %i, b = %i\n", a, b); // a = 11, b = 11

    return ;

}

//

//  main.c

//  sizeof

//

//  Created by xiaomage on 15/6/4.

//  Copyright (c) 2015年 xiaomage. All rights reserved.

//

#include <stdio.h>

int main(int argc, const char * argv[]) {

    // sizeof可以用来计算一个变量或一个常量、一种数据类型所占的内存字节数

    // 注意: sizeof是一个运算符, 不是一个函数

    // 利用sizeof计算的格式: sizeof(变量/常量/数据类型);

    // 计算常量占用的内存字节数

//    int number = sizeof(10);// 10是一个整型常量, 整型 == int == 4

    // 如果利用sizeof计算常量, 那么可以省略()

    int number = sizeof ;

    printf("number = %i\n", number);

    // 计算变量

    double doubleValue = 10.9;// doubleValue是实型 , 实型 ==  double == 8

//    int number = sizeof(doubleValue);

     // 如果利用sizeof计算变量, 那么可以省略()

    int number = sizeof doubleValue;

    printf("number = %i\n", number);

    // 计算数据类型

    int number = sizeof(char);

    // 注意: 如果利用sizeof计算数据类型, ()不能省略

//    int number = sizeof char;

    printf("number = %i\n", number);

    return ;

}

//

//  main.c

//  逻辑运算符

//

//  Created by xiaomage on 15/6/4.

//  Copyright (c) 2015年 xiaomage. All rights reserved.

//

#include <stdio.h>

int main(int argc, const char * argv[]) {

    /*

     逻辑运算符的返回值只有两种: 要么真要么假, 要么是1(真), 要么是0(假)

     &&(与运算)

     格式: 表达式1 && 表达式2

     结合性: 从左至右

     只有表达式1和表达式2都为真的时候, 逻辑与表达式才返回真

     如果表达式1或者表达式2中有一个是假, 那么逻辑与表达式返回的结果都是假

     口诀: 一假则假

     ||(或运算)

     格式: 表达式1 || 表达式2

     结合性: 从左至右

     只要表达式1或者表达式2中有一个是真的, 逻辑或表达式返回的值就是真

     只有表达式1和表达式2的值都是假, 逻辑或的值才是假

     口诀: 一真则真

     !(非运算)

     格式: !表达式

     结合性: 从右至左

     如果表达式是真, 就返回假

     如果表达式是加, 就返回真

     取反

     */

    //             1 &&  0

    int result =  >  &&  > ;

    printf("result = %i\n", result);

    //              1 ||    0

    int result =  >  ||  > ;

    printf("result = %i\n", result);

    int result = !( > );// !0

    printf("result = %i\n", result);

    // 注意点:

    // 由于C语言规定, 任何数值都有真假性, 非0即真. 所有逻辑运算符可以直接与数值进行计算

//    int result = 0 && 11;

//    int result = 0 || 0;

    // 逻辑非结合性: 从右至左

    int result = !!!!!!;//

    printf("result = %i\n", result);

    // 由于逻辑与有一个特点: 一假则假, 所以如果前面的表达式的值为假, 那么后面的表达式没有必要参与运算

//    int result = 10 > 18 && 9 > 5;

//    int a = 10;

//    int result = 10 > 18 && ++a > 5;

//    printf("result = %i , a = %i\n", result, a);

    // 由于逻辑或有一个特点: 一真则真, 所以如果前面的表达式的值为真, 那么后面的表达式没有必要参与运算

    // 逻辑与和逻辑或的这个特点, 称之为逻辑运算符的短路

    int a = ;

    int result =  >  || ++a > ;

    printf("result = %i , a = %i\n", result, a);

    return ;

}

//

//  main.c

//  三目运算符

//

//  Created by xiaomage on 15/6/4.

//  Copyright (c) 2015年 xiaomage. All rights reserved.

//

#include <stdio.h>

int main(int argc, const char * argv[]) {

    int a = ;

    int b = ;

//    int result = a > b;

    // 三目运算符格式: 条件表达式 ? 结果A : 结果B

    // 结合性: 从左至右

    // 只要条件表达式为真就返回结果A, 如果条件表达式为假, 那么就返回结果B

    // a大于b吗? 如果a大于b就返回a, 否则返回b

//    int result = (a > b)? a : b;

    // 三目运算符的优先级: 低于关系运算符和算术运算符

    //             25 > 15 ? 20 : 15

    int result = a +  > b ? a : b;

    printf("result = %i\n", result);

    // 从键盘输入3个整数, 利用三目运算符取出最大值并输出

    // 1.提示用于输出三个整数, 用逗号隔开, 以回车结束

    printf("请输入三个整数, 用逗号隔开, 以回车结束\n");

    // 2.定义三个变量保存用户输入的数据

    int num1, num2, num3;

    // 3.利用scanf函数接收用户输入的数据

    scanf("%i,%i,%i", &num1, &num2, &num3); // 17, 5, 88

    // 4.比较三个数的大小, 取出最大值

    // 4.1获取num1和num2中的最大值

//    int temp = num1 > num2 ? num1 : num2;// 17 > 5 ? 17 : 5; temp = 17

    // 4.2利用num1和num2中的最大值和剩下的num3比较

//    int result = temp > num3 ? temp : num3;// 17 > 88 ? 17 : 88; result = 88

    // youtube写法 usb写法

    // 1.阅读性比较差

    // 2.性能也比较差

    int result = (num1 > num2 ? num1 : num2) > num3 ? (num1 > num2 ? num1 : num2) : num3;

    // 5.输出结果

    printf("result= %i\n", result);

    return ;

}

巴特西

C4

最新文章

热门文章