精华内容
下载资源
问答
  • C语言符号优先级

    2019-02-06 22:19:38
    C语言符号优先级, 描述符号之间运算的先后顺序
  • C语言符号优先级.pdf

    2020-09-03 15:30:29
    附录 2 C 语言中的运算符及其优先级 附录 2 C 语言中的运算符及其优先级 优先级 运算符 名称或含义 使用形式 结合方向 说明 [] 数组下标 数组名 [ 常量表达式 ] 表达式/ 函数名 ) 圆括号 1 ( 形参表 ) 左到右 ....
  • #分享知识,分享快乐#由于个人需要,整理了一份优先级的对比文档,深知初学者的不容易,特在此分享,希望大家一起进步。
  • C语言符号优先级[借鉴].pdf
  • 最近在做一个读EEPROM中的电压数据,并把数据通过CAN报文发送到上位机的功能。 由于EEPROM读出来的数据是一个字节大小的数据,长度是8位,而电压数据大小是12位,并且,读出来后要把数据再重新整理一下。...

            最近在做一个读EEPROM中的电压数据,并把数据通过CAN报文发送到上位机的功能。

            由于EEPROM读出来的数据是一个字节大小的数据,长度是8位,而电压数据大小是12位,并且,读出来后要把数据再重新整理一下。  一串电池有12个电芯,我需要获得的电压值就是12个值,EEPROM中存储的数据就是12*12/8=18个字节。同时也知道,EEPROM中的数据是按顺序存储的。

            在读到18个字节的数据后,于是小弟我就做了以下的操作:

            /*     将18个字节的EEPROM数据,转换为12个字节的电压     */

             for(i=0,j=0;i<12;i++)
            {
        if((i%2)==0)
        {
    voltage_value[i]=(eeprom[j]<<4)+((eeprom[++j]&0xF0)>>4);
        }
        else
        {
    voltage_value[i]=((eeprom[j]&0x0F)<<8) + eeprom[++j];
    j++;
        }

            }

                获取到的电压值完全不是我想要的结果。。。。。。

                为了弄清楚咋回事,我给eeprom数组都赋了值,重新输出结果:

                /*     eeprom数组赋值,voltage_value理论结果都为0xFBD   */

                for(i=0;i<6;i++)
        {
    eeprom[i*3]=0xFB;
    eeprom[i*3+1]=0xDF;
    eeprom[i*3+2]=0xBD;

        }

                 /*     将18个字节的EEPROM数据,转换为12个字节的电压     */

                for(i=0,j=0;i<12;i++)
         {
        if((i%2)==0)
        {
    voltage_value[i]=(eeprom[j]<<4)+((eeprom[++j]&0xF0)>>4);
        }
        else
        {
    voltage_value[i]=((eeprom[j]&0x0F)<<8) + eeprom[++j];
    j++;
        }

           }

                /* 打印结果*/

        for(i=0;i<12;i++)
        {
        printf("%x\t",voltage_value[i]);

        }

            

              仔细看打印结果,会发现第一个数据为0xdfd,就已经出了问题。

              这一句 voltage_value[i]=(eeprom[j]<<4)+((eeprom[++j]&0xF0)>>4);

               运算是先进行了“++j"的操作,因此得出来的结果是voltage_value[0]=(eeprom[1]<<4)+((eeprom[1]&0xF0)>>4);

    而不是voltage_value[0]=(eeprom[0]<<4)+((eeprom[1]&0xF0)>>4);

    ========================华丽丽的分割线=====================================

              代码改一下:

            for(i=0,j=0;i<12;i++)
    {
    if((i%2)==0)
    {
    voltage_value[i]=(eeprom[j]<<4)+((eeprom[1+j]&0xF0)>>4);
    j++;
    }
    else
    {
    voltage_value[i]=((eeprom[j]&0x0F)<<8) + eeprom[1+j];
    j +=2;
    }

    }

            打印结果正常了

            

    ========================华丽丽的分割线=====================================

            或者分开来写:

            for(i=0,j=0;i<12;i++)
    {
    if((i%2)==0)
    {
    eeprom_value[i]=(eeprom[j]<<4);
    eeprom_value[i] +=((eeprom[++j]&0xF0)>>4);


    }
    else
    {
    eeprom_value[i]=((eeprom[j]&0x0F)<<8);
    eeprom_value[i] += eeprom[++j];
    j++;
    }

    }

            同样没有问题了:

    ·        

            

            

    展开全文
  • 关于C语言符号优先级

    2011-04-11 23:25:37
    关于C语言符号优先级,主要涉及8051单片机里的
  • C语言符号优先级速查

    2019-11-10 11:10:30
    C语言符号优先级速查 优先级 运算符 名称或含义 使用方式 结合方向 说明 1 [] 数组下标 数组名[常量表达式] 左到右 () 圆括号 (表达式)/函数名(形参表) . 成员选择...

    C语言符号优先级速查

    优先级运算符名称或含义使用方式结合方向说明
    1[]数组下标数组名[常量表达式]左到右
    ()圆括号(表达式)/函数名(形参表)
    .成员选择(对象)对象.成员名
    ->成员选择(指针)对象指针->成员名
    2-负号运算符-表达式右到左单目运算符
    (类型)强制类型转换(数据类型)表达式
    ++自增运算符++变量名/变量名++
    --自减运算符--变量名/变量名--
    *取值运算符*指针变量
    &取地址运算符&变量名
    !逻辑非运算符!表达式
    ~按位取反运算符~表达式
    sizeof长度运算符sizeof(表达式)
    3/表达式/表达式左到右双目运算符
    *表达式*表达式
    %余数(取模)整型表达式%整形表达式
    4+表达式+表达式左到右
    -表达式-表达式
    5<<左移变量<<表达式左到右
    >>右移变量>>表达式
    6>大于表达式>表达式左到右
    >=大于等于表达式>=表达式
    <小于表达式<表达式
    <=小于等于表达式<=表达式
    7==等于表达式==表达式左到右
    !=不等于表达式!=表达式
    8&按位与表达式&表达式左到右
    9^按位异或表达式^表达式左到右
    10|按位或表达式|表达式左到右
    11&&逻辑与表达式&&表达式左到右
    12||逻辑或表达式||表达式左到右
    13?:条件运算符表达式1?表达式2:表达式3右到左三目运算符
    14=赋值运算符变量=表达式右到左
    /=除后赋值变量/=表达式
    *=乘后赋值变量*=表达式
    %=取模后赋值变量%=表达式
    +=加后赋值变量+=表达式
    -=减后赋值变量-=表达式
    <<=左移后赋值变量<<=表达式
    >>=右移后赋值变量>>=表达式
    &=按位与后赋值变量&=表达式
    ^=按位异或后赋值变量^=表达式
    |=按位或后赋值变量|=表达式
    15,逗号运算符表达式,表达式,…左到右从左向右顺序运算
    展开全文
  • C语言运算符优先级顺序如下所示: 自增运算符 ++ 和自减运算符 --,在作后缀运算符(如表达式 x++)时,较其用作前缀运算符(如表达式 ++x)时,具有较高的优先级。 +、-、* 和 & 运算符记号不但可以当作一元...

    C语言运算符优先级顺序如下所示:

    自增运算符 ++ 和自减运算符 --,在作后缀运算符(如表达式 x++)时,较其用作前缀运算符(如表达式 ++x)时,具有较高的优先级。
    +、-、* 和 & 运算符记号不但可以当作一元运算符(unary operator,只需要一个操作数),也可以当作二元运算符(binary operator,需要两个操作数)。例如,* 只有一个操作数的时候,就是间接运算符(indirection operator),而有两个操作数的时候,就是乘号。

    文件:590m.com/f/25127180-490362842-36bac1(访问密码:551685)

    扩展资料

    一个表达式可以包含多个运算符。在这种情况下,运算符的优先级决定表达式的哪部分被处理为每个运算符的操作数。例如,按照运算规则,表达式中 *、/、以及 % 的优先级比 + 和 - 高。如下列表达式:

    a - b * c

    相当于 a-(b*c)。如果想让操作数以不同的方式组合在一起,则必须使用括号:

    (a - b) * c

    如果一个表达式中的两个操作数具有相同的优先级,那么它们的结合律(associativity)决定它们的组合方式是从左到右或是从右到左。例如,算术运算符和操作数的组合方式是从左到右,赋值运算符则是从右到左。

    【实例截图】

    在这里插入图片描述
    以下内容无关:

    -------------------------------------------分割线---------------------------------------------

    背景
    最近有个新项目可能会用到规则引擎,所以花了些时间对相关技术做调研,在百度、google用“规则引擎”作为关键字进行搜索,可以找到很多关于这方面的资料,绝大部分都会提到 drools、urules、easy-rules等等这么些开源项目,有一些文章也提到他们是采用groovy脚本来实现的。通过对项目需求的评估,初步判定groovy脚本已经可以满足实际的场景。

    然而,在这些资料或者方案之中,除了urules,大部分只是关注框架的性能和使用上的简便,很少探讨如何让业务人员可以自行进行规则定义的方案。而urules虽然自带了可视化的规则管理界面,但是界面样式不好自定义,无法跟现有后台管理界面不突兀的融合。

    通过不断尝试变换关键字在搜索引擎搜索,最终在stackoverflow找到了一个探讨这个问题的帖子,特此将帖子中提到的方案分享一下,如果你跟我一样在研究同样的问题,也许对你有用。不过在介绍这个方案之前,得先简单了解一下什么是规则引擎

    什么是规则引擎?
    简单的说,规则引擎所负责的事情就是:判定某个数据或者对象是否满足某个条件,然后根据判定结果,执行不同的动作。例如:

    对于刚刚在网站上完成购物的一个用户(对象),如果她是 “女性用户 并且 (连续登录天数大于10天 或者 订单金额大于200元 )” (条件) , 那么系统就自动给该用户发放一张优惠券(动作)。
    在上面的场景中,规则引擎最重要的一个优势就是实现“条件“表达式的配置化。如果条件表达式不能配置,那么就需要程序员在代码里面写死各种if…else… ,如果条件组合特别复杂的话,代码就会很难维护;同时,如果不能配置化,那么每次条件的细微变更,就需要修改代码,然后通过运维走发布流程,无法快速响应业务的需求。

    在groovy脚本的方案中,上面的场景可以这么实现:

    1)定义一个groovy脚本:
    def validateCondition(args){return args.用户性别 == “女性” && (args.连续登录天数>10 || args.订单金额 > 200);}
    2)通过Java提供的 ScriptEngineManager 对象去执行

    org.codehaus.groovy
    groovy
    3.0.7

    /*
    *

    • @params condition 从数据库中读出来的条件表达式
      */
      private Boolean validateCondition(String condition){
      //实际使用上,ScriptEngineManager可以定义为单例
      ScriptEngineManager engineManager = new ScriptEngineManager();
      ScriptEngine engine = engineManager.getEngineByName(scriptLang);
      Map<String, Object> args = new HashMap<>();
      data.put(“用户性别”, “女性”);
      data.put(“连续登录天数”, 11);
      data.put(“订单金额”, 220);
      engine.eval(script);
      return ((Invocable) engine).invokeFunction(functionName, args);
      }
      在上面的groovy脚本中,经常需要变动的部分就是 ”args.用户性别 == “女性” && (args.连续登录天数>10 || args.订单金额 > 200)“ 这个表达式,一个最简单的方案,就是在后台界面提供一个文本框,在文本框中录入整个groovy脚本,然后保存到数据库。但是这种方案有个缺点:表达式的定义有一定门槛。对于程序员来说,这自然是很简单的事,但是对于没接触过编程的业务人员,就有一定的门槛了,很容易录入错误的表达式。这就引出了本文的另一个话题,如何实现bool表达式的可视化编辑?

    如何实现bool表达式的可视化编辑?
    一种方案就是对于一个指定的表达式,前端人员进行语法解析,然后渲染成界面,业务人员编辑之后,再将界面元素结构转换成表达式。然而,直接解析语法有两个确定:

    1)需要考虑的边界条件比较多,一不小心就解析出错。
    2)而且也限定了后端可以选用的脚本语言。例如,在上面的方案中选用的是groovy,它使用的"与"运算符是 && , 假如某天有一种性能更好的脚本语言,它的"与"运算符定位为 and ,那么就会需要修改很多表达式解析的地方。
    另一种方案,是定义一个数据结构来描述表达式的结构(说了这么多,终于来到重点了):

    { "all": [
        { "any": [
            { "gl": ["连续登录天数", 10] },
            { "gl": ["订单金额", 200] }
        ]},
        { "eq": ["用户性别", "女性"] }
    ]}
    

    然后,使用递归的方式解析该结构,对于前端开发,可以在递归解析的过程中渲染成对应的界面元素;对于后端人员,可以生成对应的bool表达式,有了bool表达式,就可以使用预定的脚本模板,生成最终的规则。

    // 模板的例子
    def validateCondition(args){return $s;}
    /**

    • 动态bool表达式解析器
      */
      public class RuleParser {
      private static final Map<String, String> operatorMap = new HashMap<>();
      private static final ObjectMapper objectMapper = new ObjectMapper();

      static {
      operatorMap.put(“all”, “&&”);
      operatorMap.put(“any”, “||”);
      operatorMap.put(“ge”, “>=”);
      operatorMap.put(“gt”, “>”);
      operatorMap.put(“eq”, “==”);
      operatorMap.put(“ne”, “!=”);
      operatorMap.put(“le”, “<=”);
      operatorMap.put(“lt”, “<”);
      }

      /**

      • 解析规则字符串,转换成表达式形式

      • 示例:

      • 输入:

      • { “any”: [

      •    { "all": [
        
      •        { "ge": ["A", 10] },
        
      •        { "eq": ["B", 20] }
        
      •    ]},
        
      •    { "lt": ["C", 30] },
        
      •    { "ne": ["D", 50] }
        
      • ]}

      • 输出:

      • ( A >= 10 && B == 20 ) || ( C < 30 ) || ( D != 50 )

      • @param rule 规则的json字符串形式

      • @return 返回 bool 表达式

      • @throws IOException 解析json字符串异常
        */
        public static String parse(String rule) throws IOException {

        JsonNode jsonNode = objectMapper.readTree(rule);
        return parse(jsonNode);
        }

      /**

      • 解析规则节点,转换成表达式形式

      • @param node Jackson Node

      • @return 返回bool表达式
        */
        private static String parse(JsonNode node) {
        // TODO: 支持变量的 ”arg.“ 前缀定义
        if (node.isObject()) {
        Iterator<Map.Entry<String, JsonNode>> it = node.fields();
        if(it.hasNext()){
        Map.Entry<String, JsonNode> entry = it.next();
        List arrayList = new ArrayList<>();
        for (JsonNode jsonNode : entry.getValue()) {
        arrayList.add(parse(jsonNode));
        }

             return "(" + String.join(" " + operatorMap.get(entry.getKey()) + " ", arrayList) + ")";
         } else {
             // 兼容空节点:例如 {"all": [{}, "eq":{"A","1"}]}
             return " 1==1";
         }
        

        } else if (node.isValueNode()) {
        return node.asText();
        }

        return “”;
        }
        结语
        以上就是本文要阐述的全部内容,对于这个话题,如果你有这方面的经验或者更好的方案,也请多多指教,谢谢!

    展开全文
  • C语言符号优先级

    万次阅读 多人点赞 2018-04-20 12:30:03
    C语言总共有15个优先级,下面我将一一介绍 数字越大所代表的优先级越高 二. 15优先级有: 强制,下标,成员,结合性为从左向右,从左向右其实就是我们正常的数学运算符的结合性 强制:()这个符号所代表的含义...
    一. C语言总共有15个优先级,下面我将一一介绍
    
    数字越大所代表的优先级越高
    
    二. 15优先级有: 强制,下标,成员,结合性为从左向右,从左向右其实就是我们正常的数学运算符的结合性
    
    强制:()这个符号所代表的含义可以有 类型转换,参数表,函数调用。
    
    下标:[] 就是数组元素的下标。
    
    成员: -> 与. 这两个符号代表的是结构型和共用型成员。
    
    14优先级有:逻辑,位,算术,指针,算术,长度,它们的结合性为自右向左
    
    逻辑: !
    
    位 :~
    
    算术:++,--
    
    指针: &,*
    
    算术:+,-,这个是取正,取负
    
    长度:sizeof(),这个得到的是数据的长度
    
    13优先级为:* ./ .%.即乘除取模运算符
    
    12优先级为: +.-即就是加减运算符
    
    11优先级为:<<与>>即右移位和左移位运算符
    
    10优先级为:>=,>,<=,<
    
    9优先级为:==,!=
    
    8优先级为:&即位逻辑与
    
    7优先级为:^即位逻辑按位加。
    
    6优先级为:|即位逻辑或。
    
    5优先级为:&&即逻辑与
    
    4优先级为:||即逻辑或
    
    13 到 4这些优先级它们的结合性为自左向右
    
    3优先级为:“? :”即条件运算符
    
    2优先级有:赋值,自反赋值,它们的结合性为自右向左
    
    赋值:=
    
    自反赋值:+=,-=,*=,/=,%=,&=,^=,|=,<<=,>>=
    
    1优先级为:“,”即逗号运算符,它的结合性是自左向右。
    
    以上就是C语言运算符的总结了,大家是不是觉得有点眼花缭乱呢,不要着急,敏姐自有办法。
    
    三. 怎么来判断一个运算符的结合性是怎么样的呢?
    
    结合性为自左向右的运算符
    
    对于双目运算符(运算时含有两个变量的运算符),但也有一些单目运算符,它们为[],(),还有一些其它的运算符如“,”。
    
    结合性为自右向左的运算符
    
    单目运算符(即运算时只有一个变量),还有一些其它的运算符如条件运算符“? :”
    
    这就是结合性的判断啦!吐舌头
    
    
    
    四. 如何来判断运算符号的优先级
    
    这个我还真没有想出什么好的办法,我自个只能根据平时的联系啦。快哭了
    
    五.其实我觉得学习C语言就两个,一是要掌握运算符的优先级和结合性,因为这有助于我们写代码,怎么把我们的逻辑更好的表达出来,还有就是我们要掌握C 语言的语法,这有助于我们写出正确的代码。
    
    C语言是一个模块化的编程,它会把自己实现的功能不同的代码放在不同的文件中去,以此来实现模块化。
    
    

    展开全文
  • 括号成员第一;... //注意顺序:优先级(||) 低于 优先级(&&) 条件高于赋值, //三目运算符优先级排到 13 位只比赋值运算符和","高//需要注意的是赋值运算符很多! 逗号运算级最低! //逗号运算符优先级最低
  • 很清晰的表格,我在原来的基础上加以编辑,如果编辑的不好莫见笑。 Edit by G@vin 2010-01-18 如文档有不足请联系coolboy_hzh@yahoo.com.cn
  • C语言运算符优先级口诀

    千次阅读 多人点赞 2018-09-25 19:13:29
    基本的优先级需要记住: 指针最优,单目运算优于双目运算。如正负号。 先乘除(模),后加减。...C语言常用运算符的优先级口诀是:“单算关逻条赋逗”; 如果加入位运算符,完整口诀是:“单算移关与,异或逻条...
  • C语言运算符优先级列表(超详细)

    万次阅读 多人点赞 2018-09-09 11:16:34
    每当想找哪个运算符优先级高时,很多时候总是想找的就没有,真让人气愤!现在,终于有个我个人觉得非常全的,分享给大家。 初级运算符( )、[ ]、-&gt;、. 高于 单目运算符 高于 算数运算符(先乘除后加减) ...
  • C语言运算符优先级(超详细)

    万次阅读 多人点赞 2018-08-30 19:43:39
    每当想找哪个运算符优先级高时,很多时候...C语言运算符优先级   优先级 运算符 名称或含义 使用形式 结合方向 说明 1 [...
  • C语言运算符优先级排序(详解)

    千次阅读 多人点赞 2020-10-25 21:42:20
    C语言运算符 之前一直对C语言优先级这一块有疑问,每次看底层代码时,都会有很多运算符的判断,所以就找到一个比较全一点的,分享给大家。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,804
精华内容 12,721
关键字:

c语言符号优先级

c语言 订阅