精华内容
下载资源
问答
  • C语言运算表达式整理

    2018-12-29 18:25:16
    C语言的运算规则是按照运算符的优先级进行的,所以我们首先看一下C的运算优先级别 总结 最简单的优先级就是 算数运算符>关系运算符>逻辑运算符>赋值运算符 然后我们还要...

    C语言的运算规则是按照运算符的优先级进行的,所以我们首先看一下C的运算优先级别
    在这里插入图片描述

    总结 最简单的优先级就是

    1. 算数运算符>关系运算符>逻辑运算符>赋值运算符

    然后我们还要了解一个短路规则(特性)

    短路规则:在整个逻辑表达式中,同级运算符从左到右运算,当前一个分表达式的运算结果能确定整个表达式的值时,再向右的表达式统统免于运算,而以当前这个分表达式的值作为整个表达式的值。

    1. (表达式1)&&(表达式2) 如果表达式1为假,则表达式2不会进行运算,即表达式2“被短路”
      (表达式1)||(表达式2)如果表达式1为真,则表达式2不会进行运算,即表达式2“被短路”

    1.i++和++i的区别;

    i++相当于i=i+1;i++的意思是先将i进行赋值,然后在自行加1;
    ++i也是相当于i=i+1;而++i的意思是先i自加1在进行赋值;
    参考代码
    int a=1,b,c,z=1;
    b=a++; //a先将1赋值给b,b=1,;然后a在自增1;此行运行结束a=2
    c=++z; //z先自增1为2然后在赋值给c,c=2;
    printf(“表达式的值为:%d\n%d\n”,b,c); //输出结果为1和2;
    i–和--i同理;

    2.逻辑运算表达式

    在C语言中true为1,false为0,翻译过来就是真为1,假为0;
    &&两真为真,一假为假; ||一真为真,一假一真也为真;
    (表达式1)&&(表达式2) 如果表达式1为假, 则整个表达式为false=0,如果两个都为真返回1;
    (表达式1)||(表达式2) 如果表达式1为真,则表达式2不会进行运算直接返回1,如果两个都为假返回0。 //此处有用到短路特性
    例:
    a=3>2 || 6 //3>2成立直接返回1; 3>2也是返回1的,用不到6
    a=3>2 && 0 //3>2 就返回1了这时候1与0一真一假返回0;
    a=!n; //n等于任何数a都等于0;

    3.复合运算表达式

    a+=3等价于a=a+3;这种就是最简单的复合运算表达式;()
    复杂一些的有a=1;a=a+=a*=5 等价于 a=a=(a+(a=a*5))最后等于10;它的计算规则是从右往左进行的。不管有多少层的计算都是相同。

    4.逗号表达式

    逗号表达式:表达式1,表达式2
    逗号表达式的求解过程是从左到右依次进行的,但是逗号表达式会将最后一个表达式的值作为整个表达式的答案。
    例:
    b=(a=35,45,a+2) //a=15 ,表达式b=17;求解中先计算第一个表达式a=3*5=15,然后计算第二个,在计算第三个15+2为17。括号很重要如果没有括号b会为15;

    5.条件运算表达式

    条件运算符: ? : 它是唯一的一个三目运算符
    表达式1?表达式2:表达式3 它的意思是当表达式1成立就执行表达式2,如果不成立就执行表达式3;
    例如:
    3>2 ? a:b //返回a
    3>5 ? a:b //返回b

    6.左移与右移计算

    左移相当于十进制2,右移相当于/2;
    让二进制左移N位,高位丢弃,低位补0,得到的 新值 = 原值
    2^N,
    作用:实现二倍乘除运算(右移几位相当于除于二的几次方。左移几位,相当于乘上二的几次方。)
    问题:int是有符号类型,左移可能会把符号左移出去,发生溢出

    展开全文
  • 可以用括号改变优先级顺序,使得括号内的运算优先于括号外的运算。对于多重括号,总是由内到外强制表达式的某些部分优先运行。括号内的运算总是最优先计算。 一、位运算符 1.按位与运算符: & &的运算规则: ...
    每种同类型的运算符都有内部的运算符优先级,不同类型的运算符之间也有相应的优先级顺序。

    _运算符间的优先级如下:数值运算符、字符串运算符、关系运算符、逻辑运算符。可以用括号改变优先级顺序,使得括号内的运算优先于括号外的运算。对于多重括号,总是由内到外强制表达式的某些部分优先运行。括号内的运算总是最优先计算。

    一、位运算符

    1.按位与运算符: &
    &的运算规则: 操作数上下同为 1 则为 1, 否则为0
    -----------------:1&1=1, 0&0=0, 0&1=0, 1&0=0

    static void Main(string[] args)
            {
                int a = 6, b=5;
                //将a转换为二进制数为0110
                //将b转换为二进制数为0101
                int c = a + b;
                //将4转换为二进制数为0100
                Console.Write(c);
                Console.ReadKey();
            }
    

    最终结果为:4 //… 4转换为二进制数为0100
    在这里插入图片描述
    2.按位异或运算符: ^
    ^的运算规则 : 操作数上下相异则为 1,否则为 0
    -----------------:1 ^1=0, 0 ^0=0, 0 ^1=1, 1 ^0=1

    static void Main(string[] args)
            {
                int a = 6, b=5;
                //将a转换为二进制数为0110
                //将b转换为二进制数为0101
                int c = a + b;
                //将3转换为二进制数为0011
                Console.Write(c);
                Console.ReadKey();
            }
    

    最终结果为:3 //… 3转换为二进制数为0011

    3.按位或运算符: |
    | 的运算规则:操作数的上下只要有 1 则为 1,否则为 0
    -----------------:1 | 1=1, 0 | 0=0, 0 | 1=1, 1 | 0=1

    static void Main(string[] args)
            {
                int a = 6, b=5;
                //将a转换为二进制数为0110
                //将b转换为二进制数为0101
                int c = a + b;
                //将7转换为二进制数为0111
                Console.Write(c);
                Console.ReadKey();
            }
    

    最终结果为:7 //… 7转换为二进制数为0111

    4.按位取反运算符:~
    ~的运算规则:遇 10,遇 01
    -----------------:一元运算符,具有“翻转 ”位效果,包括符号位。

     static void Main(string[] args)
            {
                int a = 6;
                int c = ~a;
                //将a转换为二进制数为0110
                Console.Write(c);
                 //将c转换为二进制数为1111
                Console.ReadKey();
            }
        }
    

    最终结果为:-7 //… -7转换为二进制数为1111
    在这里插入图片描述
    5.二进制右移运算符:>>
    >> 右移规则:a >> x ----------------- x可为表达式
    -----------------:操作数右移指定的位数 x

    static void Main(string[] args)
            {
                int a = 2;
                //将a转换为二进制数为0010
                // 移动后空缺补**0** 超出舍弃
                Console.Write(a << 2);
                //输出a为:8  转换为二进制数为1000
                Console.ReadKey();
            }
    

    6.二进制左移运算符:<<
    >> 右移规则:a << x
    -----------------:操作数左移指定的位数 x

    static void Main(string[] args)
            {
                int a = 8;
                //将a转换为二进制数为1000
                 //移动后空缺补**0** 超出舍弃
                Console.Write(a >> 2);
                //输出a为:2  转换为二进制数为0010
                Console.ReadKey();
            }
    

    二、逻辑运算符

    1.逻辑运算符与: &&
    && 逻辑与运算符:两操作数都非 0为真,其余其余为假。

    static void Main(string[] args)
            {
                bool a = true;//设置两个真值
                bool b = true;
                if (a && b)
                {
                    Console.Write("true");
                    Console.ReadKey();
                }
                else
                {
                    Console.Write("false");
                    Console.ReadKey();
                }
                // 结果为: true
    

    2.逻辑运算符或: ||
    || 逻辑或运算符:两操作数任意一个非 0都为真,都假为假。

    static void Main(string[] args)
            {
                bool a = true;
                bool b = false;//改变 b 为假
                if (a && b)
                {
                    Console.Write("true");
                    Console.ReadKey();
                }
                else
                {
                    Console.Write("false");
                    Console.ReadKey();
                }
                 // 结果为: true
    

    3.逻辑运算符非: !
    !逻辑非运算符:改变操作数值,使 0变为 1

    static void Main(string[] args)
            {
                //bool a = true;
                bool b = false; //把a注释掉
                if (!b)
                {
                    Console.Write("true");
                    Console.ReadKey();
                }
                else
                {
                    Console.Write("false");
                    Console.ReadKey();
                }
                 // 结果为: true
    

    展开全文
  • 运算符划分按照功能划分:算术运算符关系...b时,a = 1,如果a运算符的优先级表运算符的优先级分为15级别,1级最高,15级最低在表达式中优先级高的优先于优先级低的先运算在一个运算量两侧的,优先级一样时按照...

    运算符划分

    按照功能划分:

    算术运算符

    关系运算符

    逻辑运算符

    按位运算符

    按照参与运算的操作个数进行划分

    单目运算符

    只有一个操作数 如:i++

    双目运算符

    有两个操作数 如:a+b

    三目运算符

    有三个操作数 如:a > b ? 1:0如果a>b时,a = 1,如果a

    运算符的优先级表

    运算符的优先级分为15级别,1级最高,15级最低

    在表达式中优先级高的优先于优先级低的先运算

    在一个运算量两侧的,优先级一样时按照运算符的结合性所规定的方向进行运算

    优先级

    运算符

    名称或含义

    使用形式

    结合方向

    说明

    1

    []

    数组下标

    数组名[常量表达式]

    左到右

    ()

    圆括号

    (表达式)/函数名(形参表)

    .

    成员选择(对象)

    对象.成员名

    ->

    成员选择(指针)

    对象指针->成员名

    2

    -

    负号运算符

    -表达式

    右到左

    单目运算符

    (类型)

    强制类型转换

    (数据类型)表达式

    ++

    自增运算符

    ++变量名/变量名++

    单目运算符

    --

    自减运算符

    --变量名/变量名--

    单目运算符

    *

    取值运算符

    *指针变量

    单目运算符

    &

    取地址运算符

    &变量名

    单目运算符

    !

    逻辑非运算符

    !表达式

    单目运算符

    ~

    按位取反运算符

    ~表达式

    单目运算符

    sizeof

    长度运算符

    sizeof(表达式)

    3

    /

    表达式/表达式

    左到右

    双目运算符

    *

    表达式*表达式

    双目运算符

    %

    余数(取模)

    整型表达式/整型表达式

    双目运算符

    4

    +

    表达式+表达式

    左到右

    双目运算符

    -

    表达式-表达式

    双目运算符

    5

    <<

    左移

    变量<

    左到右

    双目运算符

    >>

    右移

    变量>>表达式

    双目运算符

    6

    >

    大于

    表达式>表达式

    左到右

    双目运算符

    >=

    大于等于

    表达式>=表达式

    双目运算符

    <

    小于

    表达式

    双目运算符

    <=

    小于等于

    表达式<=表达式

    双目运算符

    7

    ==

    等于

    表达式==表达式

    左到右

    双目运算符

    !=

    不等于

    表达式!= 表达式

    双目运算符

    8

    &

    按位与

    表达式&表达式

    左到右

    双目运算符

    9

    ^

    按位异或

    表达式^表达式

    左到右

    双目运算符

    10

    |

    按位或

    表达式|表达式

    左到右

    双目运算符

    11

    &&

    逻辑与

    表达式&&表达式

    左到右

    双目运算符

    12

    ||

    逻辑或

    表达式||表达式

    左到右

    双目运算符

    13

    ?:

    条件运算符

    表达式1? 表达式2: 表达式3

    右到左

    三目运算符

    14

    =

    赋值运算符

    变量=表达式

    右到左

    /=

    除后赋值

    变量/=表达式

    *=

    乘后赋值

    变量*=表达式

    %=

    取模后赋值

    变量%=表达式

    +=

    加后赋值

    变量+=表达式

    -=

    减后赋值

    变量-=表达式

    <<=

    左移后赋值

    变量<<=表达式

    >>=

    右移后赋值

    变量>>=表达式

    &=

    按位与后赋值

    变量&=表达式

    ^=

    按位异或后赋值

    变量^=表达式

    |=

    按位或后赋值

    变量|=表达式

    15

    ,

    逗号运算符

    表达式,表达式,…

    左到右

    从左向右顺序运算

    虽然说运算符有很多,但是不用记住,使用小括号()扩起来就好了

    结合性简单介绍

    c语言中有两种结合性,一种是左结合型,一种是右结合性

    左结合性--自左至右运算,右结合性--自右至左运算

    左结合性 例如:x + y -z,先计算x+y,计算后的结果再减z

    右结合性 例如:x = y = z, 将z的值赋值给y,再将y的值赋值给x

    算数运算符表

    运算符

    术语

    示例

    结果

    +

    正号

    +3

    3

    -

    负号

    -3

    -3

    +

    10 + 5

    15

    -

    10 - 5

    5

    *

    10 * 5

    50

    /

    10 / 5

    2

    %

    取模(取余)

    10 % 3

    1

    ++

    前自增

    a=2; b=++a;

    a=3; b=3;

    ++

    后自增

    a=2; b=a++;

    a=3; b=2;

    --

    前自减

    a=2; b=--a;

    a=1; b=1;

    --

    后自减

    a=2; b=a--;

    a=1; b=2;

    #include

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

    /*

    + 加法

    - 减法

    * 乘法

    / 除法

    % 取模(取余)

    */

    int result;

    result = 1 + 1;

    printf("加法结果:result = %i\n",result);

    result = 1 - 1;

    printf("减法结果:result = %i\n",result);

    result = 2 * 3;

    printf("乘法结果:result = %i\n",result);

    result = 10 / 2;

    printf("除法结果:result = %i\n",result); // result = 5

    result = 10 % 3;

    printf("取模结果:result = %i\n",result); // result = 1

    return 0;

    }

    取模运算符的注意点

    注意:取模运算只能对整数取模,不能对实数取模

    // 注意取模运算只能是整数取模不能是实数取模

    // result = 10.5 % 3; // 直接报错

    注意:取模运算的正负性,取决于左边的操作数

    // 取模运算的正负性,取决于左边的操作数

    result = 10 % -3;

    printf("取模正负性结果:result = %i\n",result); // result = 1

    result = -10 % -3;

    printf("取模正负性结果:result = %i\n",result); // result = -1

    result = -10 % 3;

    printf("取模正负性结果:result = %i\n",result); // result = -1

    result = -0 % -3;

    printf("取模正负性结果:result = %i\n",result); // result = 0

    注意:如果取模运算中,左边操作数小于右边操作数,那结果直接就是左边操作数,不会进行计算了

    // 如果取模运算中,左边操作数小于右边操作数,那结果直接就是左边操作数,不会进行计算了

    result = 10 % 100;

    printf("取模结果:result = %i\n",result); // result = 10

    算术运算符的结合性

    // 算术运算符的结合性

    result = 3 + 4 + 5 + 6;

    printf("result的值是%i",result);

    算术运算符的优先级和结合性同时存在时

    先优先级,再按照结合性

    // 优先级+结合性

    result = 2 + 3 * 4 -4;

    printf("result的值是%i\n",result); // 先计算乘法,再从左至右的结合性计算

    类型转换

    隐式转换

    // 系统自动进行的转换

    int number = 10.8;

    printf("number的值是%i\n",number); // number = 10,

    // 大类型的转换成小类型的,系统会自动进行转换,由大类型转换为小类型,丢失精度

    显式转换

    // 显式转换-只需要在值前面加(类型)

    int value = (int)10.8;

    printf("value的值是%i\n",value); // 10;

    // 大类型的转换成小类型的,系统会自动进行转换,由大类型转换为小类型,丢失精度

    在算术运算中,类型不一致时,系统会先将类型统一,统一成大类型进行计算

    // 在算术运算中,类型不一致时,系统会先将类型统一,统一成大类型进行计算

    int value2 = 10 + 9.9;

    // 10是int类型,9.9是double类型,int类型占4个字节,9.9占8个字节,所以先将int转为double类型

    // int value2 = 10.0 + 9.9

    // int value2 = 19.9

    // value2 是一个int类型,但是右边的19.9是double类型,这时候系统会做隐式转换,大类型转为小类型,既结果为19

    printf("value2的值是%i\n",value2); // 19;

    算术运算符的注意点-参与运算的操作数是什么类型,那么计算出来的结果就是什么类型

    // 算术运算符的注意点-参与运算的操作数是什么类型,那么计算出来的结果就是什么类型

    int value3 = 1 / 2;

    printf("value3的值是%i\n",value3); // 打印出来的是0

    // 此时你会不会觉得是因为定义的变量是int类型导致的呢?那我就换成double类型的看看

    double value3 = 1 / 2;

    printf("value3的值是%lf\n",value3); // 打印出来的是0.000000 此时还是0

    // 是因为右侧参与运算的都是整数,那么计算的结果肯定是整数

    // 那么如果需要打印出0.5该怎么办呢?

    double value4 = 1.0 / 2; // 此时一个double除以int类型,肯定是都先转换为doublee类型,计算出的结果就是double类型,i定义的变量也是double类型不需要转换所以打印出的是0.500000

    printf("value4的值是%.1lf\n",value4);

    int value5 = 1.0 / 2;

    printf("value5的值是%i\n",value5); // 0

    新手注意常犯的错误

    // 新手注意饭的错误

    double value6 = (double)(1 / 2);

    // 右边先计算括号中的1 / 2,那么两个整数相除,结果肯定是整数,所以是0 ,由强转为double类型,为0.000000

    printf("value6的值是%lf",value6); // 0.000000

    在算术运算符中,实数的计算都是double类型,不是float类型

    赋值运算符

    最简单的赋值运算符,将等号右边的值赋值给等号左边的变量

    赋值运算符的结合性是右结合性

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

    // 最简单的赋值运算符,将等号右边的值赋值给等号左边的变量

    // 赋值运算符的结合性是右结合性

    int number = 10;

    int a;

    int b;

    a = b = 5;

    printf("a的值是%i,b的值是%i\n",a,b);

    return 0;

    }

    符合赋值运算符

    定义:在赋值符“=”加上其他的二目运算符可构成复合赋值运算符

    赋值运算符的作用是将常量、变量或表达式的值赋给某一个变量。

    运算符

    术语

    示例

    结果

    =

    赋值

    a=2; b=3;

    a=2; b=3;

    +=

    加等于

    a=0; a+=2; a = a + 2

    a=2;

    -=

    减等于

    a=5; a-=3; a = a - 3

    a=2;

    *=

    乘等于

    a=2; a*=2; a = a * 2

    a=4;

    /=

    除等于

    a=4; a/=2; a = a / 2

    a=2;

    %=

    模等于

    a=3; a%2; a = a % 2

    a=1;

    int a = 0;

    a += 3; // 这种是直接进行赋值,运算效率要好

    a = a +3; // 这一种是不是先计算再赋值给a

    printf("a的结果是%i\n",a);

    // 复合赋值运算,会先进行右边的表达式得到的值在赋值给左边的变量

    自增,自减运算符

    自增自减的第一种写法: 变量++,变量--

    int result = 10;

    result++;

    result++;

    printf("变量++,自增后的result值为:%i\n",result); // 12

    // 如果想让某一个数减1,可以使用变量--,--变量

    int value = 5;

    value--;

    printf("变量--,自增后的value值为:%i\n",value); // 4

    自增自减的第二种写法: --变量,++变量

    // 第二种写法:++变量,--变量

    int result1 = 10;

    ++result1;

    printf("++变量,自增后的result1值为:%i\n",result1); // 11

    int result2 = 5;

    --result2;

    printf("++变量,自增后的result1值为:%i\n",result2); // 4

    ​ ++,-- 在变量前面和++,-- 在变量后面的区别(在变量之前先运算再自增,在变量之后先自增再运算)

    // ++,-- 在变量前面和++,-- 在变量后面的区别

    // ++ , -- 在后面时,先参与运算然后再自增

    int a = 10;

    int b = a++;

    printf("a的值是%i,b的值是%i\n",a,b);// a的值是11,b的值是10 注意看b的值是10,而不是11,这里是a先赋值给b,然后再自增的

    // ++ --在变量之前时,是先自增再赋值

    int c = 10;

    int d = ++c;

    printf("c的值是%i,d的值是%i\n",c,d); // c的值是11,d的值是11 注意看这里d的值同样是11,所以c是先自增再赋值给d

    自增,自减练习

    // 练习

    /*

    int a = 10;

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

    // b = a++ ,此时a++的结果是11, 后面++a在a=11的基础上再自增,那么a的值就是12了,10+12

    // a =12

    printf("b的值是%i,a的值是%i\n",b,a);

    */

    /*

    int a = 10;

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

    printf("b的值是%i,a的值是%i\n",b,a); // b = 10 + 11 , a = 12

    */

    /*

    int a = 10;

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

    printf("b的值是%i,a的值是%i\n",b,a); // b = 11 + 12 ,a = 12

    */

    /*

    int a = 10;

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

    printf("b的值是%i,a的值是%i\n",b,a); // b = 11 + 11, a = 12

    */

    int a = 10;

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

    printf("b的值是%i,a的值是%i\n",b,a); // b = 10 + 11 , a = 10

    自增的拆分

    // 自增的拆分

    int a = 10;

    int b = a++;

    // 拆分:

    // 1, int b = a;

    // 2, int a = a+1;

    printf("b的值是%i,a的值是%i\n",b,a); // b = 10,a = 11

    int c = 10;

    int d = ++c;

    // 拆分

    // 1,int c = c + 1;

    // 2,int d = c;

    printf("d的值是%i,c的值是%i\n",d,c);

    // 拆分之后,只是两个表达式的顺序反了. 如果有时确实难懂的话不妨拆分一下

    sizeof运算符

    介绍:sizeof运算符可以用来计算一个变量或一个常量,一种数据类型所占的内存节数

    格式:sizeof(变量/常量/数据类型)

    注意:sizeof 不是一个函数而是一个运算符(只要是运算符就会有一个返回值)

    计算常量的内存字节

    // 使用 sizeof 计算常量的内存字节

    int number = sizeof(10.9);

    printf("10.9的e内存字节是%i\n",number); // 8

    计算变量的内存字节

    int a = 10;

    // int number = sizeof(a); // 只要是运算符就会有返回值

    int number = sizeof a; // 不加s括号e也可以

    printf("a的内存字节是%i\n",number);

    计算数据类型的内存字节(sizeof的括号不能省略)

    // 使用 sizeof 计算数据类型的内存字节

    int numChar = sizeof(char);

    printf("char 数据类型占用%i个字节\n",numChar); // 1

    int numInt = sizeof(int);

    printf("int 数据类型占用%i个字节\n",numInt); // 4

    int numDouble = sizeof(double);

    printf("double 数据类型占用%i个字节\n",numDouble); // 8

    int numFloat = sizeof(float);

    printf("float 数据类型占用%i个字节\n",numFloat); // 8

    逗号运算符

    在 C 语言中逗号也是一个运算符,称之为逗号运算符,其功能是把多个表达式连接起来组成一个表达式,成为逗号表达式

    格式: 表达式 1,表达式 2,表达式....表达式 n;

    例如:a = a + 1,b = 3*4;

    结合性:从左到右结合性

    // 逗号运算符,从左到右依次计算表达式的结果,只要是运算符就会有结果,逗号运算符也不例外

    int a = 10;

    int b = 5;

    int result;

    a = a + 10,b = b - 1,result = a + b;

    printf("a的值是%i,b的值是%i,result 的值是%i\n",a,b,result);

    逗号表达式的结果是最后一个表达式的结果

    // 定一个一个变量 number 来接收逗号表达式的结果,每个表达式用括号括起来,整体再括起来,逗号表达式的结果是最后一个逗号表达式的结果

    int number = ((a = a + 10),(b = b - 1),(result = a + b));

    printf("a 的值是%i,b 的值是%i,result 的值是%i,number 的值是%i\n",a,b,result,number);

    关系运算符

    在 c 语言中条件成立为真,条件不成立为假,判断条件是否成立就是判断条件的真假

    怎么判断条件的真假呢? C 语言中规定任何数值都有自己的真假性,任何非 0 的都为真,也就是说 100,-50,2.3这些都是真,只有 0 是假的

    关系运算符的结果只有两个结果,真和假

    C 语言的比较运算中, “真”用数字“1”来表示, “假”用数字“0”来表示。

    运算符

    术语

    示例

    结果

    ==

    相等于

    4 == 3

    0

    !=

    不等于

    4 != 3

    1

    <

    小于

    4 < 3

    0

    >

    大于

    4 > 3

    1

    <=

    小于等于

    4 <= 3

    0

    >=

    大于等于

    4 >= 1

    1

    关系运算符的返回值要么真要么假

    // > , < , >= , <= , == , !=

    int a = 10;

    int b = 5; // 怎么知道 a>b 呢? 任何的运算符都有结果

    int c = 20;

    int result = a > b;

    int result1 = a > c;

    printf("result的值是%i\n",result); // 1

    printf("result1的值是%i\n",result1); // 0

    关系运算符的优先级: > < >= <=的优先级大于 == , !=

    // 关系运算符的优先级: > < >= <=的优先级大于 == , !=

    int a = 10;

    int b = 5;

    int result = 1 == a > b; // 先计算 a 是否大于 b,再拿这个结果与 1 是否相等,

    printf("result 的值是%i",result); // 1

    算术运算符的优先级大于关系运算符(比较运算符)

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

    int result = 1 + 1 > 2+2;

    printf("result 的值是%i\n",result); // 0,先计算 1+1,在计算 2+2,再拿 2>4?

    关系运算符的结合性是左结合性

    // 关系运算符的结合性是左结合性

    int result = 10 > 5 > 20;

    printf("result 的值是%i\n",result); // 0,先计算 10>5,再拿这个值与 20做比较

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

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

    int result = 10 + 1 > 5 + 4 == 3 > 1;

    // 先计算 10+1,再计算 5+4,这两个算术运算符,得出 11 > 9 == 3>1

    // 再计算 11 > 9 ,和 3 > 1 这两个优先级比较高的比较运算符表达式,

    // 最后计算 1 == 1 等于的表达式

    printf("result 的值是%i\n",result); // 11 > 9 == 3 > 1 ---> 1 == 1 ---> 1

    开发中没有人会按照上面那么写的

    int result1 = (10+1) > (5+4) == (3>1);

    printf("result1 的值是%i\n",result1); // h实际开发中为了阅读,还是加上括号

    逻辑运算符

    有时候我们需要满足多个条件同时成立才能执行代码,比如登录:需要输入正确的用户名,和正确的密码,才能登录.所以c 语言提供了逻辑运算符

    C 语言中提供了三个逻辑运算符

    && 逻辑与表达式 1 && 表达式 2

    || 逻辑非 表达式 1 || 表达式 2

    ! 逻辑非 ! 表达式 2

    逻辑运算符的运算结果只有两个真和假

    逻辑与:只有表达式都为真,结果才是真,其余都是假

    结合性:从左至右

    // 逻辑与(一假则假)

    int result = 10 > 7 && 5 > 3; // 10>7为真,5>3 为真

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

    int result1 = 10 > 90 && 8 >1; // 10 > 90为假

    printf("result1 = %i\n",result1); // 0

    逻辑或:只要有一个表达式为真,结果就是真,如果表达式都是假,结果才是假

    结合性:从左至右

    // 逻辑或 (一真则真)

    int result = 10 > 8 || 9 > 7;

    printf("result = %i\n",result); // 都为真--真

    int result1 = 10 > 8 || 9 > 10;

    printf("result1 = %i\n",result1); // 一个为真--真

    int result2 = 10 > 11 || 9 > 10;

    printf("result2 = %i\n",result2); // 都为假--假

    int result3 = 10 > 11 || 9 > 8; // 一个为真--真

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

    逻辑非(如果表达式为真,则为假,如果表达式为假,则为真)---取反

    结合性:从右至左

    // 逻辑非

    int result = ! 10; // 0

    int result1 = ! 0; // 1

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

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

    注意点;C 语言规定,任何数值都有真假性,非 0 既真,所有的逻辑运算符可以直接约数值进行计算

    逻辑与的特点是一假则假,所以如果前面的表达式是假的话,那么后面的表达式就不会计算了

    int a = 10;

    int result = 10 < 8 && a++ > 5; // a = 10,result = 0

    // 由于 10 < 8 为假,所以后面的表达式就不会计算了,a++ 后,a 的值就没有自增

    int b = 20;

    int result1 = 10 > 8 && b++ >5; // 10 > 8 为真,后面的表达式继续计算,所以 b 的值是 21

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

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

    逻辑或的特点是一真则真,所以如果前面的表达式是真的话,那么后面的表达式就不会计算了

    int a = 10;

    int result = 10 > 8 || a++ > 5; // a = 10,result = 0

    // 由于 10 > 8 为真,所以后面的表达式就不会计算了,a++ 后,a 的值就没有自增

    int b = 20;

    int result1 = 10 < 8 || b++ >5; // 10 < 8 为假,后面的表达式继续计算,所以 b 的值是 21

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

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

    以上两个逻辑运算符的特点称之为:逻辑运算符的短路

    判断一个数值是否在一个范围内

    int a = 10;

    if (a > 3 && a < 100){

    printf("a在 3-100 之间");

    } else{

    printf("a 不在 3-100 之间");

    }

    三目运算符

    格式:条件表达式 ? 结果 A: 结果 B

    如果表达式为真,返回结果 A,如果表达式为假,返回结果 B

    结合性:左结合性

    // 三目运算符

    int a = 10;

    int b = 20;

    int result = a > b;

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

    // 如果我想获取两个数之间的最大数呢?

    if (a>b){

    printf("a 和 b 之间最大数是%i\n",a);

    }else{

    printf("a 和 b 之间最大数是%i\n",b);

    }

    // 可是上面的办法太麻烦了,x要写这么多行代码

    int maxNum = a > b ? a:b; // 这句话的意思是,如果a> b,那就返回 a,如果 a 不大于 b 的话,那就返回 b

    printf("a 和 b 之间最大数是%i\n",maxNum);

    三目运算符练习

    // 从控制台输入三个整数,返回最大的整数

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

    int num1,num2,num3;

    scanf("%i,%i,%i",&num1,&num2,&num3);

    int temp = num1 > num2 ? num1 : num2; // 比较 num1 和num2 中的最大值

    int maxNum = temp > num3 ? temp : num3; // 拿到 num1 和 num2 的最大值再与 num3 做比较,返回最大值

    printf("num1,num2,num3 之间的最大值是:%i\n",maxNum);

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

    // 不推荐这种写法是因为,问号之前计算了一次num1 和num2 的最大值,问号表达式之后又计算了一次,无疑消耗了性能

    printf("num1,num2,num3 之间的最大值是:%i\n",maxNum1);

    哎呀妈呀,运算符终于写完了!

    展开全文
  • 逻辑运算符和表达式

    2011-06-27 15:29:00
    逻辑运算符和表达式 逻辑运算符C语言中提供了三种逻辑运算符 &...逻辑运算符和其它运算符优先级的关系可表示如下: 按照运算符的优先顺序可以得出: a>b && c>d等价(a>b) && (c>d) !b==c||d a+b>c && x+yc) &&

    逻辑运算符和表达式

      逻辑运算符C语言中提供了三种逻辑运算符 && 与运算 || 或运算 ! 非运算 与运算符&&和或运算符||均为双目运算符。具有左结合性。 非运算符!为单目运算符,具有右结合性。逻辑运算符和其它运算符优先级的关系可表示如下:

      按照运算符的优先顺序可以得出:

      a>b && c>d等价于(a>b) && (c>d)
      !b==c||d<a等价于((!b)==c)||(d<a)
      a+b>c && x+y<b等价于((a+b)>c) && ((x+y)<b)

      逻辑运算的值

      逻辑运算的值也为“真”和“假”两种,用“1”和“0 ”来表示。其求值规则如下:

      1.与运算&&参与运算的两个量都为真时,结果才为真,否则为假。例如,5>0 && 4>2,由于5>0为真,4>2也为真,相与的结果也为真。

      2.或运算||参与运算的两个量只要有一个为真,结果就为真。 两个量都为假时,结果为假。例如:5>0||5>8,由于5>0为真,相或的结果也就为真

      3.非运算!参与运算量为真时,结果为假;参与运算量为假时,结果为真。

      例如:!(5>0)的结果为假。

      虽然C编译在给出逻辑运算值时,以“1”代表“真”,“0 ”代表“假”。 但反过来在判断一个量是为“真”还是为“假”时,以“0”代表“假”,以非“0”的数值作为“真”。例如:由于5和3均为非“0”因此5&&3的值为“真”,即为1。

      又如:5||0的值为“真”,即为1。

      逻辑表达式逻辑表达式的一般形式为: 表达式 逻辑运算符 表达式 其中的表达式可以又是逻辑表达式,从而组成了嵌套的情形。例如:(a&&b)&&c根据逻辑运算符的左结合性,上式也可写为: a&&b&&c 逻辑表达式的值是式中各种逻辑运算的最后值,以“1”和“0”分别代表“真”和“假”。

    void main(){
     char c='k';
     int i=1,j=2,k=3;
     float x=3e+5,y=0.85;
     printf("%d,%d/n",!x*!y,!!!x);
     printf("%d,%d/n",x||i&&j-3,i<j&&x<y);
     printf("%d,%d/n",i==5&&c&&(j=8),x+y||i+j+k);
    } char c='k';
    int i=1,j=2,k=3;
    float x=3e+5,y=0.85;
    printf("%d,%d/n",!x*!y,!!!x);
    printf("%d,%d/n",x||i&&j-3,i<j&&x<y);
    printf("%d,%d/n",i==5&&c&&(j=8),x+y||i+j+k);  

      本例中!x和!y分别为0,!x*!y也为0,故其输出值为0。由于x为非0,故!!!x的逻辑值为0。对x|| i && j-3式,先计算j-3的值为非0,再求i && j-3的逻辑值为1,故x||i&&j-3的逻辑值为 1。对i<j&&x<y式,由于i<j的值为1,而x<y为0故表达式的值为1,0相与,最后为0,对i==5&&c&&(j=8)式,由于i==5为假,即值为0, 该表达式由两个与运算组成,所以整个表达式的值为0。对于式x+ y||i+j+k 由于x+y的值为非0,故整个或表达式的值为1。

    展开全文
  • 离散数学学习笔记——命题逻辑命题联结词命题联结词的真值表命题联结词的优先级命题联接词与开关电路命题联接词与逻辑电路命题联接词与网页检索命题联接词与位运算 命题联结词 命题联接词 “∧”、“∨”、“↔” ...
  • 这种硬线逻辑电路系统就是广泛应用各种现 代通讯电子设备与计算机系统中的专用集成电路(ASIC)或 FPGA。本书着重介绍进入九十 年代后才开始在美国等先进的工业国家逐步推广的用硬件描述语言(Verilog HDL) 建模...
  • Matlab—基本操作与矩阵输入

    千次阅读 2019-09-30 09:15:06
    Matlab 运算符分五类:数学、关系逻辑、位、集合运算符 数学运算符 其主要功能是进行各种数学运算,按其优先级别依次为: 转置.’、共轭转置'、幂次.^、矩阵幂次^ 正、负号+、- 乘法.*、矩...
  • C语言知识串讲(CH4)

    2020-06-18 22:02:58
    2.逻辑运算符和逻辑表达式:逻辑运算发及其优先次序,逻辑表达式。 3.条件运算符和条件表达式。 4.条件语句:if语句的三种形式,if语句的嵌套。switch开关语句。 1)语句if(!E);中的表达式!E等价(E==0) 2) ...
  • 1. i++和++i的区别 2. Java中的按位与(&)、按位或(|)、异或(^)等运算符 按位与运算符(&) 参加运算的两个数据,按二进制位进行“与”运算。...关系运算(比较大小)优先于逻辑运...
  • 如下表,上一行的运算总是优先于下一行。 只有单目运算,赋值运算是从右往左运算的。 梳理了一个大概的优先级 1:括号,++, -- 2: 单目运算 3:算术运算符 4:移位运算 5:关系运算符 6:位...
  • 算术运算符优先于关系运算符优先于赋值运算符。C++逻辑运算符有&&(逻辑与),||(逻辑或),!(逻辑非)三种,逻辑表达式运算结果为"真"或"假"。非0为真,0为假。同时,分支结构可以用if语句或switch语句实...
  • 1算术运算符及表达式 算术运算符包括: ,-,*...=优先于==,!=。 (3)关系表达式成立时值为1,不成立时值为0。 3逻辑运算符及表达式 (1)逻辑运算符包括:&&(逻辑与),||(逻辑或),!(逻辑非)。
  • 优先级:*、/优先于+、-,可用括号控制。 二元运算符:左结合运算 右结合运算:赋值运算符、条件运算符、?:、??、??= 运算符按类别优先级排序:基本、一元、范围、乘法、加法、移位、关系和类型、 相等、...
  • C语言中,运算bai符除了常见的三大类,算术运算符、关系运算符与逻辑运算符之外,还有一些用于完成特殊任务的运算符。 运算符的运算优先级共分为15 级,1 级最高,15 级最低。 在表达式中,优先级较高的先优先级较...
  • C语言 运算符优先级

    2019-09-12 09:46:06
    C语言中,运算符除了常见的三加粗样式大类,算术运算符、关系运算符与逻辑运算符之外,还有一些用于完成特殊任务的运算符。 在表达式中,优先级较高的先优先级较低的进行运算。而在一个运算量两侧的运算符 优先级...
  • 5.常用零碎知识

    2018-12-12 18:50:02
    一、逻辑运算符 C++语言中提供了三种逻辑运算符:与...逻辑运算符和其他运算符优先级关系如:  按照运算符的优先顺序可以得出:  a&gt;b&amp;&amp;c&gt;d 等价(a&gt;b)&amp;&amp...
  • C语言中,运算符除了常见的三大类,算术运算符、关系运算符与逻辑运算符之外,还有一些用于完成特殊任务的运算符。 运算符的运算优先级共分为15 级,1 级最高,15 级最低。在表达式中,优先级较高的先优先级较低的...
  • java运算符

    2019-02-21 18:38:52
    一元运算符肯定优先于二院运算符 二元运算符优于三元运算符 赋值运算符,也是特殊的,是超级落后 二元运算符里面有自己的鄙视链 (鄙视链来了) 数学运算符优于移位运算符(+、-、*、/) 移位运算符优于...
  • 2.Java基础语法.ppt

    2019-08-13 22:21:53
    在单独运算的时候 ++i,i++ 没有任何区别,都是加1操作相当 i=i+1 i++;先运算,后加1(先运算后加减) ++i;先加1,后运算(先加减后运算) 2.逻辑运算符(&&,||,!,^) 逻辑非 ! 取反 逻辑异或 ^ 操作数一样...
  • 它们之间允许进行运算运算结果为长整型。但c,d被定义为基本整型,因此最后结果为基本整型。本例说明,不同类型的量可以参与运算并相互赋值。其中的类型转换是由编译系统自动完成的。有关类型转换的规则将在以后...
  • 3.6 关系运算逻辑运算 3.6.1 关系运算和关系表达式 3.6.2 逻辑常量和逻辑变量 3.6.3 逻辑运算和逻辑表达式 3.7 选择结构和if语句 3.7.1 if语句的3种形式 3.7.2 if语句的嵌套 3.8 条件运算符和条件表达式 3.9 多...
  • 3.6 关系运算逻辑运算 3.6.1 关系运算和关系表达式 3.6.2 逻辑常量和逻辑变量 3.6.3 逻辑运算和逻辑表达式 3.7 选择结构和if语句 3.7.1 if语句的3种形式 3.7.2 if语句的嵌套 3.8 条件运算符和条件表达式 3.9 多...
  • 5.9.5 运算式的真假关系 48 5.10 三目运算符 50 5.10.1 三目运算符的优先问题 50 5.10.2 三目运算符的使用问题 51 5.10.3 三目运算符的型别问题 51 5.10.4 三目运算符在字符型变量中的使用 52 5.11 复杂嵌套...
  • >数学运算符>关系运算符>逻辑运算符...... 如碰到不确定优先级的情况下,请用括号码()来确保优先顺序。 4 数值格式 如需输入二进制,请以0b开头,中间不能有空格。举例:0b11 即为3 如需输入十六进制,请以0x...

空空如也

空空如也

1 2 3
收藏数 55
精华内容 22
关键字:

关系运算优先于逻辑运算