标签: post-increment

我无法理解以下代码块.

   int count = 0;
   for (int i = 0; i < 3; i++){
       count += (count++);
       System.out.println("count = " + count);
       System.out.println("i = " + i);
   }

我的理解是循环运行三次以执行以下操作

count = count + count
count = 1 + count

这将转换为以下内容,因为count最初为0:

count = 0 + 0
count = 1 + 0 = 1
count = 1 + 1 = 2
count = 1 + 2 = 3
count = 3 + 3 = 6
count = 6 + 1 = 7 …

    #include <stdio.h>

    int main()
    {
        int x = 0;

        if (x++)
            printf("true\n");
        else if (x == 1)
            printf("false\n");
        return 0;
    }

输出:

false

为什么输出错误？

x++是后增量; 这意味着使用的值x然后递增.如果是这样,那么x=0应该使用,答案应该是真的.

从OCP Java SE 6程序员实践考试的第280页开始,问题9:

int x = 3;
x = x++;
// x is still 3

在解释中我们可以读到:

该x = x++;行不会离开,x == 4因为在分配发生后++应用 了该行.

我同意这x是3,我理解增加后.

我不同意这个解释.我会用"之前"替换"之后".

我认为它的工作方式如下:

1. x 是3.

2. x++被执行.我将此增量后运算符视为函数:

   int operator++() {
       int temp = getX();
       setX(temp + 1);
       return temp;
   }
   

   Run Code Online (Sandbox Code Playgroud)

   因此,x++执行后,x是4,但从x++表达式返回的值是3.

3. 现在,分配=.简单地写返回3到x.

因此,在我的眼中,在分配发生之前++应用.我错了吗？

我有给定的代码,它会收到错误:

错误:从'int'类型的rvalue中无效初始化'int&'类型的非const引用const int b = f(a ++); ^

int f(int& a)
{
    return a;
}

int main() {
    // your code goes here
    int a = 5;
    int b = f(a++);
    std::cout << b << std::endl;
    return 0;
}

这个错误的原因是什么？

在Python中,我们如何在列表的方括号内增加或减少索引？

例如,在Java中使用以下代码

array[i] = value
i-- 

可写成

array[i--] 

在Python中,我们如何实现它？ list[i--]不管用

我目前正在使用

list[i] = value 
i -= 1 

请提供一个简洁的方法来实现此步骤.

最近,我将我的项目从gcc 4.3升级到gcc 5.5.之后,我看到后增量运算符中的行为更改导致了我的项目中的问题.我使用全局变量作为控制变量.例如,请考虑以下示例程序:

int i = 0;
int main()
{
        int x[10];

        x[i++] = 5; ===> culprit

        return 0;

}

在上面的代码片段中,值i应该仅在5分配之后递增x[0],以保证x[0]在i递增之前分配有适当的有效值.

现在问题出现了,我看到在移动到gcc 5.5之后,汇编指令已经改变,并且即使在赋值发生之前,i的值也会增加.以上片段的汇编说明:

Dump of assembler code for function main():
6       {
   0x0000000000400636 <+0>:     push   %rbp
   0x0000000000400637 <+1>:     mov    %rsp,%rbp

7               int x[10];
8
9               x[i++] = 1;
   0x000000000040063a <+4>:     mov    0x200a00(%rip),%eax        # 0x601040 <i>
   0x0000000000400640 <+10>:    lea    0x1(%rax),%edx
   0x0000000000400643 <+13>:    mov    %edx,0x2009f7(%rip)        # 0x601040 <i>  ====> i gets incremented …

在所有关于Java的书籍中,我都读到编译器以相同的方式处理所有空格并简单地忽略了额外的空格,因此最好的做法是大量使用它们来提高代码的可读性.我已经在我写过的每一个表达中找到了证据:无论是否有空格都没关系,有多少(或者我只是没注意).

最近我决定尝试运算符优先级和关联性来测试优先级表并尝试编译

int a = 2;
int b = 3;    
int c = a+++b;
int d = a+++++b;

虽然前一个陈述完美汇编,但后者产生了一个例外:

线程"main"中的异常java.lang.RuntimeException:无法编译的源代码 - 意外类型.必需:变量.发现:价值.

但是,当我添加空格:时int d = a++ + ++b,它编译.为什么会这样？据说Java无论如何都会忽略额外的空格.(如果这很重要,我有Java 8和Netbeans IDE 8.2.)

我想这可能与解析表达式有关,但我不确定.我尝试在SO和Google上查找有关解析,空白和运算符的几个问题,但找不到明确的答案.

UPD.为了解决那些重要的"额外"的评论,而不是所有的空白:既然int c = a++ + b;又int c=a+++b;编译,可以说,通过类比,在int d = a ++ + ++b;空白中也是"额外的".

只是为了看看我对++c/c++运算符的工作原理了解多少，我尝试运行这些 C 程序：

int c = 5;
c = c - c++;
printf("%d\n", c);

打印 1，我猜逻辑是 ++ 在使用它的代码行之后应用，因此c变为= c - c0，并在“下一行”增加一。但对我来说似乎很奇怪，我想更详细地了解操作员优先级应该发生什么。

现在开始：

int c = 5;
c = c - ++c;
printf("%d\n", c);

这个打印0，我真的不明白为什么。如果从左到右解析右手值，我想它会读取c哪个是 5，然后++c哪个是 6，因为它应该立即应用。或者它是否++c在整个右手值计算之前计算，因此它实际上是在做 6 - 6，因为增量还涉及第一次调用c？

在以下代码中：

int main() {
   int i, j;

   j = 10;
   i = (j++, j+100, 999+j);

   cout << i;

   return 0;
}

输出为1010。

但是，它不应该是 1009，就像++在使用整个表达式之后应该做的那样吗？

代码

#include<iostream>
int main()
{
    int a=3;
    a++=5;
    std::cout<<a;
}

输出（如预期）

[Error] lvalue required as left operand of assignment

1.后增量运算符 ( a++) 在表中具有最高优先级。所以它肯定会在赋值运算符 ( =)之前执行。并且根据后增量规则，变量的值a只有在执行该语句后才会增加。

那么当后增量运算符 ( ++) 在赋值运算符 ( =)之前执行时究竟会发生什么？

2. 在C 中，前自增运算符和后自增运算符都产生右值，但C++将前自增运算符更新为左值，同时将后自增运算符仅保留为右值。原因是我们不能让它成为左值，因为它只有旧值，而不是更新的值。但我不能正确理解这个原因。

现在a++看到右值是 3，而不是变量本身，对吧？但是如果它带来一个拥有左值的变量，那么 5 将插入其中，并且在语句结束后它的值将是 6。这有什么问题，为什么不能这样做？