C-007.C语言中的运算符

根据操作数来分类：
单目运算符：操作数只有一个
双目运算符：操作数有两个

三目运算符：操作数有三个

一般分类为以下几类：

*****1.算数运算符：

+  正号

-   负号

+ 加
- 减
* 乘
/ 除

% 取模 或 取余
1、取模运算符的正负性取决于前面那个操作数正负
2、取模运算符的操作数只能是整数

int main(int argc, const char * argv[]) {
    //1.正号 和 负号
    int a = 1;        //正号基本不写
    int b = -1;
    printf("%d,%d\n",a,b);  //输出1,-1
    
    //2.加减乘除取余
    int c = 1 + 2;
    int d = 4 - c;
    int e = c * d;
    double f = c / d;
    int g = -199 % 10;  //不能写成 int g = 199 % -10;
    printf("%d,%d,%d,%lf,%d\n",c,d,e,f,g);

    
    return 0;
}

*****2.赋值运算符 

赋值运算符 

=  等于

复合赋值运算符

+=  加等于
-=   减等于
*=   乘等于
/=   除等于
%= 模等于

int main(int argc, const char * argv[]) {
    /*
     赋值运算符：就是把等号右边的数值放到左边的变量中，同时它做一个表达式本身有值，它值就是右边那个数
     赋值运算算的结合方向：从右往左的
     
     算术运算符的优先级要高于赋值运算符的优先级
     */
    int i = 1;  //这里的"="就是赋值运算符  把1赋值给i这个变量
    printf("%d\n",i);
    
    int a = 2;
    a += 10;//  等价于 a = a + 10;
    a -= 8; //  等价于 a = a - 8
    a *= 2; //  等价于 a = a * 2;
    a /= 4; //  等价于 a = a / 4;
    a %= 2; //  等价于  a = a % 2;
    
    printf("a = %d\n",a);
    
    // 所有赋值运算符的优先级都是小于算术运算符的，
    // 赋值运算符是所有运算符中除了逗号运算符以外优先级最低的
    int b = 4;
    
    b *= 2 + 3;
    
    printf("b = %d\n",b);//先进行算数运算，再进行赋值运算 所以结果是 4*（2+3）= 20


    
    return 0;
}

*****3.自增自减运算符

无论++在前还是++在后a本身都会自增 1

 a = 2

 ++a;  a本身会自增1,它的返回值(结果)是原来的 a + 1的值

 a++;  a本身会自增1,它的返回值(结果)是原来的 a的值

 

 无论--在前还是--在后a本身都会自减 1

 --a;  a本身会自减1，它的返回值(结果)是原来的a - 1 的值

 a--;  a本身会自减1，它的返回值(结果)是原来的a 的值

int test1()
{
    int a = 2;
    
    int b = a++ + a++; // a = 4
    
    b = ++a + a++; // a = 6
    
    b = ++a + ++a; //a = 8
    
    b = a++ + ++a;// b = 8 + 10   a = 10
    
    printf("a = %d,b = %d\n",a,b); //输出a = 10 , b = 18
    
    return 0;
}


int main(int argc, const char * argv[]) {
    
    //  a++;
    //  1、 a = a + 1;
    //  2、 (a++) = (原来)a
    //  3、 a++ 先参与其他运算然后再自增1
    
    
    //    ++a; // 先自增1然后再参与其他运算
    //  1、a = a + 1
    //  2、(++a) = (原来)a + 1


    int a = 10;
    int b = ++a;// 等价于 a = a + 1;
    printf("b = %d\n",b);// 11
    int c =  a++;// 等价于 a = a + 1;
    printf("c = %d\n",c);// 11
    printf("a = %d\n",a);
    
    test1();
    
return 0;
}

*****4.sizeof运算符

sizeof运算符：用来计算常量，变量，以及数据类型(指的是这种数据类型的变量或常量)所占用存储空间的字节数

int main(int argc, const char * argv[]) {
    
    //  sizeof作用在数据类型，表示这个中数据类型的常量或者变量所占用存储空间
    //  类型本身是不占用存储空间，只有这种类型的数据才占用存储空间
//在C语言中所有表达式都由返回值(结果)
//结合方向：从左往右
//返回值：  最后一个表达式的值
    int size = sizeof(int);//  当sizof作用在数据类型上，那么小括号是不可以省略的
    printf("%d\n",size);
    
    //  常量
    //  sizeof 是运算符不是函数，当它用在常量上面可以省略小括号
    //  sizeof 常量 或 sizeof(常量)
    
    int  size1  = sizeof(1);
    printf("%d\n",size1);  //1是一个int类型 所以是4
    
    size1 = sizeof 2.3;
    printf("%d\n",size1); //2.3是一个double类型 所以是8

    // 当sizeof 作用在变量上 sizeof(变量名称) sizeof 变量名称
    int a = 10;
    int size2  =  sizeof(a);
    printf("size = %d\n",size2);
  
    return 0;
}

*****6.逗号运算符

在C语言中所有表达式都由返回值(结果)

结合方向：从左往右
返回值：   最后一个表达式的值

int main(int argc, const char * argv[]) {
    
    printf("%d\n",(1,2,3)); //输出3
    
    int a = 1;
    int b = 2;
    int c = 3;
    printf("%d\n",(a,b,c + 1)); //输出4
    
    //  注意点：
    
    int d,e,f;//这不是一个逗号表达式，这个是定义多个变量的简便方式
    
    
    return 0;
}

*****7.关系运算符

所有的关系运算符都是用来比较两个数据的，它们的结果只有两个要么是真(1)要么假(0)

 

 >   大于

 <   小于

 >=  大于等于

 <=  小于等于

 上面的四个比较运算符的优先级要大于后面的两个

 !=  不等于

 ==  等于

 赋值运算符的优先级 < 比较运算符的优先级 < 算术运算符的优先级

 比较运算符的结合性： 从左往右的

int main(int argc, const char * argv[]) {
    
    //  比较运算符的结合性从左往右的
    
    int result = 5 > 6 < 4 < 3;
    printf("%d\n",result);       //输出1

    //  当我们不确定某些运算符的优先级的时候，可以使用() 来明确优先级
    result = (5 == 5) < 4;
    
    printf("%d\n",result);  //输出1
 
    
    return 0;
}

*****8.逻辑运算符

逻辑运算符：所有逻辑运算符他们的结果只有两个要么真(1)要么是假(0)

&& 逻辑与 (并且)
&& 只要有一个表达式为假，那么整个表达式的结果就为假
&& 如果左边的表达式为假，那么右边的表达式就不参与运算(与断路)
口诀： 一假则假
结合方向： 从左往右

|| 逻辑或 (或者)
1、只要有一个表达式为真，那么整个表达式的结果就为真
2、如果前面的表达式为真，那么后面的表达式就不参与运算了(或断路)
口诀：一真则真
结合方向：从左往右

&& 和 || 的优先级要小于 关系运算符的优先级 大于 赋值运算符的优先级


! 逻辑非
1、真变假，假变真
2、结合方向：从右往左
3、它优先级要高于比较运算符和算术运算符的优先级

int test()
{
    //逻辑或使用
    
    int result =  0 || 6;
    
    int a = 10;
    int b = 12;
    //  优先级越高的只是越先结合(剥洋葱)
    result =  (b > a) || (a++ > b && 0);//前面b > a已经为真后面不在运行和计算所以a还是10
    
    
    printf("result = %d,a = %d \n",result,a);//result = 1， a = 10；
    
    return 0;
}


int main(int argc, const char * argv[]) {
    
    //逻辑与使用
    int a = 1;
    int b = 3;
    int c = 2;
    int result = c < a && c < b;//根据一假即假的原则，c < a 已经为假 直接判断为假 后面不参与计算
    printf("%d\n",result);//输出0

    //在C语言中所有数值都是有真假性，所有非零的数都为真，只有0为假
  
    result = 2 && 1;
    printf("%d\n",result);//输出1

    test();//逻辑或使用
    
    //逻辑非使用
    result  = !(1 > 3);//1 > 3输出是0，前面加！ 变成1
    
    printf("%d\n",result);//输出1

    
    
    return 0;
}

*****9.三目运算符

条件表达式：由关系运算符或逻辑运算符构成表达式

 条件表达式 ? 结果1 : 结果2;

 如果条件表达式成立就返回结果1 否则 就返回结果2

int main(int argc, const char * argv[]) {
    
    int a = 10;
    
    int result  =  a > 4 ?  a : 5; //第一个条件表达式成立 输出 a的值
    
    printf("result = %d\n",result);//输出10
    
    return 0;
}