C语言入门（三）之运算符、sizeof运算符、if表达式

类型转换、类型提升

#include 
void test();
int main(int argc, const char * argv[]) {
    // 1.类型转换
    /*
    // int 占用4个字节 double 占用8个字节
    // 只是相同类型的数据才能进行运算, 隐式类型转换 将小类型转换为大类型, 然后再进行运算
    // 在赋值的时候系统又给我们进行了一次隐式类型转换
    // 发现, 如果在隐式类型转换的时候, 将大类型转换为小类型会丢失精度
    int result = 10.9;
    printf("result = %d\n", result);
    
    // 强制类型转换格式: (类型)被强制类型转换的数据
    int result2 = (int)10.9;
    printf("result2 = %i", result2);
    
    // 自动类型提升
    // 自动类型的提升, 将参与运算的数据都转换为同一类型后再运算
    // 会自动将小的数据类型提升为大的数据类型
    int result3 = 1 + 9.9; // 1.0 + 9.9 = 10.9
     */
    
    /*
    // 在算术运算中, 参与运算的是什么类型, 计算出来就是什么类型
//    double result = 1.0 / 2; // 1.0 / 2.0 --> 0.5
//    double result = (double)1 / 2;// 1.0 / 2.0 --> 0.5
    double result = (double)(1 / 2); // (double)(0) --> 0.0
    printf("result = %lf\n", result);
     */
    
    // 2.算术运算符的结合性, 左结合, 从左至右的计算
    // 3.算术运算符的优先级 * / % 大于 + -
    // 如果优先级和结合同时存在, 那么先优先级再结核性
//    int result = 3 + 4 * 5 + 6;
//    printf("result = %i\n", result);
    
    //test();
    return 0;
}

void test()
{
    /*
     + 加法
     - 减法
     * 乘法
     / 除法
     % 取模(取余)
     */
    // 1.定义变量保存计算结果
    int result;
    // 2.开始计算
    result = 1 + 1;
    result = 1 - 1;
    result = 2 * 2;
    result = 6 / 3;
    // 注意: 取模运算只能用于整数
//    result = 10 % 3;
//    result = 12 % 5;
//    result = 10.0 % 3.0;
    // 取模运算的正负性取决于左边的操作数, 如果左边为负数, 那么结果就是负数
//    result = 10 % -3;
//    result = -10 % -3;
//    result = -10 % 3;
    
    // 如果取模运算的左边小于右边, 那么结果就是左边
    result = 2 % 9;
    
    // 3.验证计算结果
    printf("result = %i\n", result);
}

赋值运算符

#include 

int main(int argc, const char * argv[]) {
    
    // 1.最简单的赋值运算符
    // 赋值运算符的结合性: 从右至左
//    int result = 10;
    
    // 2.复合赋值运算符: += -= *= /= %=
    int result = 10;
//    result = result + 5;// result = 10 + 5; result = 15
//    result += 5; // 相当于 result = result + 5;
    result -= 5; // 相当于result = result - 5;
    printf("result = %i\n", result);
    return 0;
}

自增自减

#include 

int main(int argc, const char * argv[]) {
    
    // 1.自增自减基本概念
    /*
    int result = 10;
//    result = result + 5;
//    result += 5;
    
//    result = result + 1;
//    result += 1;
    // 自增: 如果想让某一个数加1可以使用自增
//    result++;
//    result++;
//    result = result - 1;
//    result -= 1;
    // 自减: 如果想让某一个数减1可以使用自减
//    result--;
     */
    
    // 2.自增的两种写法
    /*
//    result++;
//    ++result;
    // 自减的两种写法
    result--;
    --result;
     printf("result = %i\n", result);
    */
    
    // 3.自增自减写在前面和后面的区别
    /*
    // 如果++写在变量的前面, 那么会先将变量自增再用自增之后的结果参与运算
    // 如果++写在变量的后面, 那么会先将变量的值参与运算再将变量自增
    // 总结一句话: ++在前, 先自增再运算, ++在后, 先运算再自增
    int a = 10;
//    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;
    //       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 = 10;
//    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 0;
}

sizeof运算符

sizeof不是函数，是运算符，用来计算变量、常量、数据类型所占的内存字节数。

#include 

int main(int argc, const char * argv[]) {
    // sizeof可以用来计算一个变量或一个常量、一种数据类型所占的内存字节数
    // 注意: sizeof是一个运算符, 不是一个函数
    // 利用sizeof计算的格式: sizeof(变量/常量/数据类型);
    
    // 1.计算常量占用的内存字节数
    /*
//    int number = sizeof(10);// 10是一个整型常量, 整型 == int == 4
    // 如果利用sizeof计算常量, 那么可以省略()
    int number = sizeof 10;
    printf("number = %i\n", number);
     */
    
    // 2.计算变量
    /*
    double doubleValue = 10.9;// doubleValue是实型 , 实型 ==  double == 8
//    int number = sizeof(doubleValue);
     // 如果利用sizeof计算变量, 那么可以省略()
    int number = sizeof doubleValue;
    printf("number = %i\n", number);
     */
    
    // 3.计算数据类型
    
    int number = sizeof(char);
    // 注意: 如果利用sizeof计算数据类型, ()不能省略
//    int number = sizeof char;
    printf("number = %i\n", number);
    

    return 0;
}

逗号运算符

关系运算符

0代表假，其他都为真

     >
     <
     >=
     <=
     ==
     !=

逻辑运算符

&&（短路与，一假则假，前面的表达式为假，真个表达式为假，不需要计算后面的表达式）

||（短路或，一真则真，前面的表达式为真，后面的表达式不需要计算，整个表达式为真）

！

三目运算符

if表达式

// C语言中, 任何数值都有真假性, 非0即真
    if (0) {
        printf("来这二\n");
    }else
    {
        printf("不去\n");
    }

上面代码始终输出不去

如果要判断某一个变量是否等于某一个值, 建议把常量写前面, 变量写后面

if (18 = age) {
        printf("开网卡\n");
    }

石头剪刀布

#include 
#include 

int main(int argc, const char * argv[]) {
    /*
     有两个角色 : 玩家(我), 电脑
     两个角色都可以出 0 == 石头/ 1 == 剪子 / 2 == 布
     由于我们不知道玩家和电脑到底出的什么拳, 所以我们用0, 1, 2来代替石头/ 剪子 / 布
     玩家的出拳可以让用户自己输入
     电脑的出拳必须生产一个随机数, 如何生产随机数?
     将玩家的出拳和电脑的出拳进行比较, 得到比赛结果
     
     石头 > 剪刀 / 剪刀 > 布 / 布 > 石头
     */
    // 1.生产电脑的出拳
    // arc4random_uniform方法会根据传入的整数生产一个随机数
    // 生成的值就是 0~(N-1)的值
    int cmp =  arc4random_uniform(3);
//    printf("cmp = %i\n", cmp);
    // 2.接收玩家的出拳
    // 2.1定义变量保存玩家的出拳
    int player = -1;
    // 2.2利用scanf接收
    printf("请输入出拳, 0代表石头, 1代表剪刀, 2代表布\n");
    scanf("%i", &player);
    // 3.比较玩家和电脑的出拳
    if (((0 == player)&&(1 == cmp)) ||
        ((1 == player) && (2 == cmp)) ||
        ((2 == player) && (0 == cmp))) {
            printf("玩家获胜\n");
    }else if (((0 == cmp)&&(1 == player)) ||
              ((1 == cmp) && (2 == player)) ||
              ((2 == cmp) && (0 == player)))
        {
            printf("电脑获胜\n");
        }else
        {
            printf("以和为贵\n");
        }
    printf("player = %i, cmp = %i\n", player, cmp);
    return 0;
}