标签: operator-precedence

在我的语法高亮显示器中,我使用正则表达式来解析不同的术语.下面是我解析PHP类的方法:

foreach ( PHP::$Classes as $class )
    $code = preg_replace( "/\b{$class}\b/", $this->_getHtmlCode( $class, PHP::$Colors['class'] ), $code );

现在,只需忽略PHP类和_getHtmlCode函数.正则表达式"/\b{$class}\b/"匹配诸如的名称count.如果我创建一个名为的变量$count,那么匹配就好了.

如何查找前面没有的类名$？

可能重复:
运算符优先级问题

我们知道前缀的优先级大于"LOGICAL AND"(&&),"LOGICAL AND"的优先级大于"LOGICAL OR"(||).

以下程序似乎违反了它:

int main()

{
    int i=-3,j=2,k=0,m;
    m=++i||++j&&++k;
    printf("%d %d %d %d",i,j,k,m);
    return 0;
}

如果优先级++大于&&,||则应首先执行所有前缀.在此之后i=-2,j=3,k=1,然后&&将首先执行.为什么输出显示:-2 2 0 1？

该程序的行为在ubuntu v12.04上也是相同的.

所以假设你有一个非常基本的人物对象,有两个值和一个函数:

function personObject() {
    this.name = 'First Name';
    this.placeInLine = 1;
    this.setPlaceInLine = function(place) {
        this.placeInLine = place;
    }
}

我们设置了一些这样的变量:

var john = new personObject();
var bill = new personObject();
var message = "";

现在看看下面的三个代码片段......

---代码#1 ---

if(john.placeInLine < bill.placeInLine) message = "John is before Bill";
else message = "John is not before Bill";

结果:消息="约翰不在比尔之前"; //因为1不小于1

---代码#2 ---

bill.setPlaceInLine(2); // change Bill's place to 2 (instead of default of 1)
if(john.placeInLine < bill.placeInLine) message = "John is before Bill"; …

我有以下测试程序:

#include <string>
#include <iostream>

int main()
{
    std::string s;
    std::string a = "sd";

    std::cout << a==s ? "y" : "n";

    return 0;
}

尝试编译它g++ test.cpp会产生以下神秘错误:

error: no match for 'operator==' (operand types are 'std::basic_ostream<char>' and 'std::string {aka std::basic_string<char>}')
  std::cout << a==s ? "y" : "n";
                ^

它似乎s被正确编译为类型std::string,而a被编译为std::basic_ostream<char>!？救命!!

让我们说a ='hi'

我想知道a是否是以下任何'hi','yes'或'no'我可以运行

a='hi'
a=='hi' or a=='yes' or a=='no'
>>>True

但是,让我们说这是一个很长的可能性列表,所以我只想说

a='hi'
a==('hi' or 'yes')

当我这样做时,我得到的答案是真的但是当我做这样的事情时:

a==('yes' or 'hi')
>>>False

然后这也很奇怪

a==('yes' and 'hi')
>>>True

但如果我再次切换它们

a==('hi' and 'yes')
>>>False

有人可以解释这里发生的事情

从Kathie Sierra的OCA/OCP Java SE 7程序员I和II学习指南中找到的书:

int x = 2;
int y = 5;
if ((x > 3) && (y < 2) | doStuff()) {
    System.out.println("true");
}

这现在打印......什么都没有!因为前面的代码(少了一组括号)评估就像你说的那样,"如果(x> 3)不是真,并且(y <2)或者doStuff()的结果为真,那么打印true那么,如果(x> 3)不成立,那么在查看表达式的其余部分时没有意义"由于短路&&,表达式被评估为好像周围有括号(y <2)| 做东西().

在我的理解中,运营商&&和||具有相同的优先级,并从左至右评估.因此,在这种情况下,(x > 3) && (y < 2)仍应首先评估表达式.请解释.

更新:我的错误.这确实是一个"|" 而不是"||".

我编译代码时收到下面报告的错误.你能错误地纠正我吗？

无效的类型参数->(有int)

我的代码如下:

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

typedef struct bundles
    {
    char str[12];
    struct bundles *right;
}bundle;

int main() {

    /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
    unsigned long N;
    scanf("%lu", &N);
    bundle *arr_nodes;
    arr_nodes = malloc(sizeof(bundle)*100);
    int i=5;
    for(i=0;i<100;i++)
    {
    scanf("%s", &arr_nodes+i->str);
    printf("%s", arr_nodes+i->str);
    }
    return 0;
}

我在这些方面面临问题:

scanf("%s", &arr_nodes+i->str);
printf("%s", arr_nodes+i->str);

我是Haskell的新手,我在这里得到了一个无限循环,但我不知道为什么.

module Main where

pow :: Int -> Int -> Int
pow x 0 = 1
pow x y = x * pow x y-1

main :: IO ()
main = print( pow 2 3 )

有任何想法吗？

我们假设我们有以下代码片段:

void foo(std::unique_ptr<Data> p1, std::unique_ptr<Data> p2){
    bar(p1);
    bar(p2);
}

int main(){
    foo( std::unique_ptr<Data>{new Data}, std::unique_ptr<Data>{new Data});
}

问题是:运行此代码时是否会释放内存(无论发生什么情况)？

标准说我们不能依赖语句的顺序作为函数参数,但内部函数调用/内存分配等呢？它在这里重要吗？

在以下代码中,

int a = 1, b = 2, c = 3, d;
d = a++ && b++ || c++;
printf("%d\n", c);

输出将是3,我得到或评估第一个条件,将其视为1,然后不关心其他条件,但在c中,一元运算符的优先级高于逻辑运算符,就像在数学中一样

2 * 3 + 3 * 4

我们首先评估产品然后求和来评估上述表达式,为什么不做同样的事情呢？首先评估所有一元运算符,然后是逻辑事物？