标签: post-increment

以下代码打印出"3",而不是"4",如您所料.

public class Foo2 {
    public static void main(String[] args) {
        int a=1, b=2;             
        a = b + a++;
        System.out.println(a);
    } 
}

我明白了.在加载"a"的值之后发生后缀增量.(见下文).

我不太明白的是为什么.postfix ++的运算符优先级高于+所以不应该先执行？

% javap -c Foo2

Compiled from "Foo2.java"
public class Foo2 extends java.lang.Object{
public Foo2();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   iconst_1
   1:   istore_1
   2:   iconst_2
   3:   istore_2
   4:   iload_2
   5:   iload_1
   6:   iinc    1, 1
   9:   iadd
   10:  istore_1
   11:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   14: …

我试图使用++运算符增加一个变量,但我不断得到NaN结果,我不知道为什么.这是我的代码:

var wordCounts = { };
var x = 0
var compare = "groove is in the heart";
        var words = compare.split(/\b/);
        for(var i = 1; i < words.length; i++){
            if(words[i].length > 2){
                wordCounts["_" + words[i]]++;
            }
        }


alert(wordCounts.toSource());

每(优秀)质询C++输出迭代增量后的要求,我们观察到,对于一提领和递增的值r的OutputIterator类型X,和值o适当类型的,所述表达

*r++ = o;

是有效的,并具有相同的语义

X a(r);
++r;
*a = o;

但是,a如果r在中间期间增加不止一次,那么仍然可以解除引用吗？也就是说,这段代码有效吗？

X a(r);
++r;
++r;
*a = o;

很难看出对值的操作如何影响对另一个值的操作的有效性,但是例如InputIterator(24.2.3)在以下条件下的后置条件下++r:

之前的任何值的副本r都不再需要可解除引用或属于其中==.

相关章节:24.2.2迭代器,24.2.4输出迭代器,17.6.3.1模板参数要求.

此外,如果这不是必须有效的,是否有任何情况下利用其无效性将有助于类型的实现(wrt效率,简单性),OutputIterator同时仍然遵守现有要求？

在Flash中测试此代码:

var i:int = 0;
for (var j:int = 0; j < 5000000; j++)
{
    i=i+1;
}// use about 300ms.

i = 0;
for (var j:int = 0; j < 5000000; j++)
{
    i++;
}// use about 400ms

i = 0;
for (var j:int = 0; j < 5000000; j++)
{
    ++i;
}// use about 400ms too

为什么i=i+1ActionScript 3中的速度更慢？

对不起,我犯了一些错误.上面的代码使用的时间相同.但如果把它投入使用,结果会有所不同.

var i:int;
var j:int;
var startTime:Number;

function func1():void
{
    i = i + 1;
}

function func2():void
{ …

为什么k没有增加,而i和j在同一个表达式中增加.我也想知道程序的输出是什么.我得到输出为-2 3 1 0

#include <stdio.h>
void main()
{
 int i=-3, j=2, m, k=0;
 m=++i && ++j || ++k;
 printf("%d %d %d %d", i, j, m, k);
}

y=x++;

在没有优化而不是CPU级别或指令的情况下,它在编译器级别中断了多少个步骤？是否创建任何临时值以将x分配给y,或者直接发生？

考虑这个简单的代码:

 // E1 
  public void doTest(String pattern) {
    int counter = 0;

    while (counter < 3) {
        counter = counter++;
    }
    System.out.println("Done");
}

这会导致无限循环.

但是,如果增加计数器的语句是这样写的:

E2.  counter = ++counter;

或这个

E3.    counter++;

它正常终止.我理解增量发生在失败的版本中的赋值之后,这解释了为什么E2工作,但我认为java分配了变量的增量结果,如E3中那样递增.所以我很困惑为什么E1失败但E3没有.

我从未看过一个教程或一些讲座,这些讲座显示了一个经典的for-loop,而不是后增量顺序.

for (int i=0; i<array.length; i++) {}

如果使用POST增量,变量"i"将被缓存,然后才会增加!但这没有任何意义,因为命令直接结束.

在我看来,这更有意义:

for (int i=0; i<array.length; ++i) {}

如果你到现在才明白,我会更进一步(为我的英语而烦恼):

在第一个循环中:

1. 缓存i的实际值.(注意:之间没有动,所以没有理由这样做)
2. 增量我
3. 前进

在第二个循环中:

1. 直接增加我
2. 前进.

所以第二个循环的性能更高,没有质量损失.还有其他意见吗？

我来到这个表达式,并且无法理解以下代码段中第3行的含义:

int A=0, B=0;
std::cout << A << B << "\n"; // Prints 0, 0
A += B++ == 0; // how does this exp work exactly? 
std::cout << A << B << "\n";  // Prints 1, 1

A为它添加B,B为Post增加1,"== 0"是什么意思？

编辑:这是实际的代码:

int lengthOfLongestSubstringKDistinct(string s, int k) {
    int ctr[256] = {}, j = -1, distinct = 0, maxlen = 0;
    for (int i=0; i<s.size(); ++i) {
        distinct += ctr[s[i]]++ == 0; // 
        while (distinct > k)
            distinct -= --ctr[s[++j]] == …

我发现以下程序的意外输出。

这里的指针ptr指向变量的地址i并i保存值10。这意味着价值ptr也10。下ptr一次递增一次。这意味着现在它拥有价值11。但是在以下程序中ptr打印12。

#include <iostream>
using namespace std;    

int main()
{
    int i = 10;
    int *ptr = &i;
    int j = 2;
    j += *ptr++;

    cout<<"i : "<<i<<"\n";
    cout<<"j : "<<j<<"\n";
    cout<<"ptr : "<<*ptr<<"\n";
}

输出：

i : 10
j : 12
ptr : 12

所以我不明白为什么要ptr打印12而不是11？