i+++j

解析i+++j运算

最新推荐文章于 2024-01-27 09:15:14 发布

原创最新推荐文章于 2024-01-27 09:15:14 发布 · 1.1k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#i+++j

C 专栏收录该内容

1 篇文章

订阅专栏

关于这个i+++j就是一个简单的运算，实际写代码的时候不会有人这么写的。

但是这个问题真的很有意思

我靠着感觉蒙出了正确的答案

#include<stdio.h>
int main(){
    int i=1,j=2;
    printf("%d\n",i+++j);
    printf("%d\n",i);
    return 0;
}

i+++j 即 (i++)+j

这样就能验证正确答案了！

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

U_HighProfileMan

关注关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

你真正的了解i++和++i吗?

啊渊的专栏

10-26

2517

一个菜鸟新手问题，佬大你知道以下代码的运行结果吗？ int x=3; int y=(++x)+(++x)+(++x); 我自豪的答到，这个不简单吗？15 因为++x =4,每一次x的值都被改变+1,因此y=4+5+6 = 15. 菜鸟说，是不是电脑坏了，你过来看看运行结果。 y = 16。大型翻车现场。我立马写了一份代码：main.c #include <stdio.h> int main(int agrc,char** args){ int x = 3,y,z1 ,z2,z3,re

i++ 与 i.getAndIncrement() 性能比较

HeatDeath的博客

03-21

2141

import java.util.concurrent.atomic.AtomicInteger; public class IncrementCompare { public static void main(String[] args) { int N = 1000000000; int i = 0; AtomicInteger j ...

参与评论您还未登录，请先登录后发表或查看评论

i+++j语句是正确的吗

子谦博客

02-23

4409

相信很多人看到 i+++j 就傻眼了，这是正确的吗，如果是正确的，那执行顺序是什么？ public class ThreePlus { public static void main(String[] args) { int i = 10; int j = 20; int k = i+++j; System.out.print...

i+++j的理解

懒人_人懒

03-28

1万+

例子一：(假设该包含的头文件都已包含)int i =1, j=2;int k = i+++j;std::cout<< k << std::endl;分析：拆解为 i++ 和 j ， i++先计算后+1，所以 k输出3.

【Java语法解析】i+++j应该如何计算？

luoyingting的专栏

03-22

1670

文章目录语法话题语法分析最长可能解析原则原则解析问题思考原则的例外例外1——例外2—— 语法话题本期的话题如下： i+++j应该如何计算？关于该表达式，在类似于C / C++中讨论是没有多大意义的，因为C / C++依赖于实现的硬件结构，不同的环境结果也会不同。不过在Java中，这个结果是固定的，不受其运行的硬件环境与平台所影响。语法分析我们可以将表达式解析成两种可能的形式： i + (++j) (i++) + j 以上的括号不是必须的，这里仅为了清晰起见（后面也是如此）。我们可以通过

i = j++

hanhanhanxu的博客

12-06

1596

赋值号，先执行右边的，再将右边的结果赋值给左边。所以先执行j++再将其结果赋值给i。 j++实现： const int int::operator(int) { int oldValue = *this; ++(*this); return oldValue; } 所以是先进行j++，比如j从1变为2，然后将旧值1返回，返回结果赋值给i。这叫做运算符重载，之前我大一还写过，现在都忘...

莫衷一是——i+++j 该如何计算？

yujianta14的博客

04-07

8251

这是一个有趣的计算， 3 个加号相连。那么，到底是如何结合的呢?是按照： i + (++j)来运算，还是按照(i++) + j 来运算呢?　　这个问题在类似于 C / C++中讨论是没有多大意义的，因为 C / C++依赖于实现的硬件结构，不同的环境结果也会不同。不过在 Java 中，这个结果是固定的，不受其运行的硬件环境与平台所影响。

C与C++中++i和i++的区别

superhoner的博客

03-03

5369

C与C++中++i和i++的区别文章目录C与C++中++i和i++的区别前言一、C++中区别二、C中区别前言 i++和++i很明显的区别就是：++i是先对i进行加一操作然后再返回i的值，而i++是先返回i的值再对i进行加一操作。 int main() { int i = 1, j = 1; cout << "i++:" << i++ << endl; cout << "++j:" << ++j << en

给定一个整数数组，求a[i]+a[j]+i-j的最大值—头条笔试题

Kaiyang_Shao的博客

05-25

2362

问题给定一个整数数组，求数组中两个数关于公式 a[i]+a[j]+i-j 的最大值，即找两个数，这两个数相加并减去两个数之间的下标距离，求得最大值。例如： input: 3 1 2 3 output: 4(选择的两个数是2和3) 扩展：这个题目可以有变形，例如求一个数组中两数和的最大值，两数差的最大值，或两数和差和某些变量构成的公式的最大值。思路（1）基本思路：暴力搜索，遍历每一个数对，进...

「杂谈」由C/C++中(++i)+(++i)+(++i)+(++i)表达式的计算结果引申出的疑问

Jack's Blog

03-19

6179

非计算机专业的老师讲到C/C++中，i=2时，(++i)+(++i)+(++i)+(++i)的计算结果的时候，给出的答案是19。我感到很困惑，按照正常的计算逻辑结果应该是18，于是我到菜鸟教程的在线编译器上面试了一下，得到的结果是18，后来又在Xcode上试了一次，得到的结果也是18，更换了ACM竞赛专用的codeblocks编译，结果是19。贴出代码： #include "stdio.h" ...

莫衷一是——i+++j 该怎样计算？

weixin_30518397的博客

08-16

496

　　这是一个有趣的计算， 3 个加号相连。那么，究竟是怎样结合的呢?是依照： i + (++j)来运算，还是依照(i++) + j 来运算呢? 　　这个问题在相似于 C / C++中讨论是没有多大意义的，由于 C / C++依赖于实现的硬件结构，不同的环境结果也会不同。只是在 Java 中，这个结果是固定的。不受其执行的硬件环境与平台所影响。　　究竟依照什么顺序运算呢，写...

C++中是如何运算+++++i+++++j++++这个表达式的

fuyun2000的专栏

01-07

1346

所以最先读取到一个符号+，再往后也是一个符号+，那么组合起来就是++，而++是C++里面能识别出来的最长的一个符号，是一个自增运算符，如果再往后读一个字符就是+++了，这显然在C++中是没有这样的运算符，也无法作为变量的名称，所以从这里就可以分割开了，以次类推。++++i+j++也是可以的，会解析成(++(++i))+(j++) ,++i是左值，所以可以再进行++操作。组合起来其实就是(++(++(+((i++)++))))+((j++)++)当然i+++j是可以，会解析成 (i++)+j。

C语言基础之i+++j；

aw的博客

08-25

7846

如果i=1，j=2；i+++j的值是多少。 #include<stdio.h> #include<math.h> int main() { int i=1,j=2; printf("%d\n",i+++j); printf("i=%d\n",i); printf("j=%d\n",j); return 0; } 该问题考察的是同一优先级下代码的执行顺序，以及i++和++i的区别该语句从左到右执行， i++ +j；运行完此句后 i

Java_语法基础_i+++j该如何计算

03-22

3026

这是一个有趣的计算，3个加号相连。那么，到底是如何结合的呢？这个问题在类似于C/C++中讨论是没有多大意义的，因为C/C++依赖于实现的硬件结构，不同的环境结果也会不同。不过在Java中，这个结果是固定的，不受其运行的硬件环境与平台所影响。例：package deep;public class PlusPlus { public static void main(String[] arg

i++与++j区别

叁笙侑幸

11-05

1081

#i++：先赋值再运算 i=1; let x=i++; echo "x=$x" echo "i=$i" #++j先运算再赋值 j=2; let x=++j; echo "x=$x"; echo "j=$j";

C语言如何理解i+++j？

PAP

01-27

1384

C语言系统如何处理表达式i+++j？

关于j = ++i++;

timerzip的博客

01-04

1410

下面语句： int i=0,j; j = ++i++;是错误的。原因如下：后置递增运算符的优先级高于前置递增，因而j = ++i++;等价于 j= ++(i++); 由于 i++ 返回的是原始 i 的一个副本，且是作为不可更改的右值，因而对这个右值进行前置递增会出错。 Ps: 前置递增返回的是递增后的对象本身。

i++和++j的区别

黄同学的博客

12-30

1241

i++和++j的区别

java i=i++和j=i++的区别

最新发布

10-08

<think>我们讨论的是C/C++/Java等语言中的表达式解析问题。用户的问题是关于表达式`i+++j`为什么被解析为`(i++) + j`而不是`i + (++j)`，但用户现在想查找是否存在`i+++j`等于`i+(++j)`的情况。首先，我们需要明确：在标准语法中，`i+++j`总是被解析为`(i++)+j`。但是，用户想知道是否有可能在某些情况下，这个表达式的值等于`i+(++j)`。注意：我们讨论的是表达式的值相等，而不是解析方式相同。考虑两种表达式：表达式A: (i++) + j 表达式B: i + (++j) 分析它们的行为：表达式A: 先取i的当前值，然后计算i+j，之后i自增1（因为后缀++）。注意：整个表达式使用的是i自增之前的值。表达式B: 先对j自增1，然后取j的新值，再计算i+j（此时j已经增加）。注意：整个表达式使用的是j自增之后的值。那么，在什么情况下，A的值会等于B的值？设A的值为：vA = i (旧值) + j (旧值) 执行后：i变为i+1，j不变。设B的值为：vB = i (当前值) + (j+1) [因为++j使得j增加1，并且使用增加后的值] 执行后：i不变，j变为j+1。因此，要使vA等于vB，需要满足： i_old + j_old = i_old + (j_old + 1) => j_old = j_old + 1 这显然是不可能的（除非1等于0，这是不可能的）。所以，从数学上来说，在任意初始值下，表达式A的值都不可能等于表达式B的值。但是，我们需要注意：如果表达式中有副作用，且i和j不是简单的变量而是复杂的表达式，或者有运算符重载（如C++），情况可能不同？然而，在基本数据类型的情况下（如int），并且i,j是独立的变量，那么： vA = i + j vB = i + (j+1) 所以，vA和vB总是相差1。因此，一般情况下，`i+++j`（即`(i++)+j`）的值不可能等于`i+(++j)`的值。但是，如果考虑多线程环境，或者有其他的副作用（比如在计算i和j的过程中有函数调用改变了其他值），但这里表达式是简单的变量。另外，在C++中，如果重载了运算符，那么行为可能被改变。但是，对于内置类型，行为是确定的。结论：对于内置类型的整型变量，`(i++)+j`的值总是等于`i+j`（并且之后i增加1），而`i+(++j)`的值总是等于`i+(j+1)`（并且j增加1）。因此，它们永远不相等。但是，有一种特殊情况：当j不是基本类型，而是有重载运算符的类对象时，行为可能被自定义。然而，即使在这种情况下，通常也不会让`(i++)+j`等于`i+(++j)`，因为这样会违反通常的自增运算符的语义。所以，答案是：在标准的语义下，不存在`i+++j`等于`i+(++j)`的情况。两者的值总是相差1。然而，如果用户的问题是关于在解析上如何强制使`i+++j`被解析为`i+(++j)`，那么答案是不可能，因为词法分析规则（最大贪婪匹配）已经决定了它被解析为`(i++)+j`。如果要得到`i+(++j)`，必须加上括号。因此，回答用户的问题：`i+++j`等于`i+(++j)`的情况是不存在的（对于基本类型）。但是，为了严谨，我们可以举一个例子，说明在什么情况下两个表达式的值可能相等？实际上，我们上面已经证明，对于基本类型，它们不可能相等。那么，我们考虑非基本类型的情况（例如C++中的运算符重载）？假设我们有一个自定义类型，它重载了`++`和`+`运算符，并且我们故意让后置++返回的值和前置++返回的值有某种关系，但这通常不会改变表达式的基本含义。例如： class Number { int value; public: Number(int v) : value(v) {} // 重载后置++: 标准做法是返回旧值 Number operator++(int) { Number old = *this; value++; return old; } // 重载前置++: 返回新值 Number& operator++() { value++; return *this; } // 重载+运算符 Number operator+(const Number& other) const { return Number(value + other.value); } // 为了比较，重载== bool operator==(const Number& other) const { return value == other.value; } int getValue() const { return value; } }; 然后我们定义： Number i(5), j(3); 表达式1： (i++) + j -> 相当于：i的旧值（5）加上j（3）得到8，然后i变为6，j不变。表达式2： i + (++j) -> 此时i是5（因为表达式1执行后i变为6，但这里我们重新初始化），j先自增为4，然后i(5)+j(4)=9。所以仍然不相等。如果我们改变重载的行为，例如让后置++返回的值也是自增后的值（违反常规）： Number operator++(int) { value++; return *this; // 错误：后置++应该返回旧值，但这里返回新值 } 那么表达式(i++)+j就会变成：i自增后（6）再加上j（3）得到9。而表达式i+(++j)中，j先自增为4，然后i(6?)加上j(4)得到10？注意，这时i已经是6了（因为前面执行了i++）？这里我们必须注意执行顺序。假设我们重新初始化：i=5, j=3。表达式A: (i++)+j 步骤1：执行i++，它返回了*this（此时i已经变为6），所以返回值是6（但按照语义，后置++应该返回5，但我们在这里故意返回6）。步骤2：6+j(3) = 9。表达式B: i+(++j) 步骤1：执行++j，j变为4，返回j（4）。步骤2：此时i的值？注意，在表达式A中i已经变为6，所以这里i是6。步骤3：6+4=10。所以还是不等。那我们再尝试另一种情况：让后置++返回一个特别的值。例如，我们让后置++返回一个比实际旧值大1的值（即模拟了前置++的效果）？这仍然违反常规。或者，我们通过全局变量等方式来干扰？比如： int counter = 0; class Number { int value; public: // ... 其他同上 Number operator++(int) { counter++; Number old = *this; value++; return old; } Number& operator++() { counter++; value++; return *this; } Number operator+(const Number& other) const { return Number(value + other.value + counter); // 在加法中加上counter } }; 然后，我们观察：初始化：i=5, j=3, counter=0。表达式A: (i++)+j counter初始为0。执行i++：先保存旧值5，然后i变为6，counter变为1（因为是后置++，所以调用operator++(int)）。然后执行加法：5（i的旧值） + j(3) + counter(1) = 5+3+1=9。执行完后，counter=1。表达式B: i+(++j) counter现在是1（因为刚刚执行过表达式A，但这里我们重新初始化：i=5, j=3, counter=0）重新初始化：counter=0, i=5, j=3。执行++j：j自增为4，counter变为1（调用前置++）。执行加法：i(5) + j(4) + counter(1) = 5+4+1=10。所以还是不等。结论：无论如何，两个表达式的值都不可能相等。因此，我们回答用户：在标准的编程语言（如C/C++/Java）中，表达式`i+++j`（即`(i++)+j`）的值不可能等于`i+(++j)`的值。两者总是相差1（在整型情况下），或者由于运算符重载的复杂性也几乎不可能相等。因此，不存在这种情况。但是，用户可能会问：如果i和j不是整型，而是浮点型？即使浮点型，1的差距仍然存在。所以，最终答案：不可能相等。 </think>### `i+++j` 与 `i+(++j)` 的值关系分析在 C/C++/Java 等语言中，表达式 `i+++j` **永远不可能等于** `i+(++j)` 的值（其中 `i, j` 为基本数据类型如 `int`）。原因在于两者的计算过程和副作用存在本质差异： #### 1. **表达式解析与执行顺序** | 表达式 | 等价形式 | 计算步骤 | 最终值 | |--------------|---------------|---------------------------------------------|---------------| | `i+++j` | `(i++) + j` | 1. 取 `i` 的原始值<br>2. 计算 `原始值 + j`<br>3. `i` 自增 1 | `i_原 + j` | | `i + (++j)` | `i + (++j)` | 1. `j` 先自增 1<br>2. 取 `j` 的新值<br>3. 计算 `i + j_新` | `i + (j+1)` | #### 2. **数学关系证明** 设初始值 $i = a$，$j = b$（$a, b$ 为任意整数）： - `(i++) + j` 的值 = $a + b$ - `i + (++j)` 的值 = $a + (b+1) = a + b + 1$ 二者恒满足： $$(i++) + j \equiv i + (++j) - 1$$ 即 **两者的值始终相差 1**，不可能相等。 #### 3. **变量状态变化对比** ```java // Java 验证示例 int i = 5, j = 3; int result1 = i++ + j; // (i++) + j // 结果: result1 = 8 (5+3), i=6, j=3 i = 5; j = 3; // 重置初始值 int result2 = i + (++j); // i + (++j) // 结果: result2 = 9 (5+4), i=5, j=4 ``` 输出差异： - `result1 = 8`，`result2 = 9` → 相差 1 - `i` 和 `j` 的最终状态也不同（见下表） | 表达式 | 结果值 | 副作用 | |----------------|--------|----------------------| | `(i++) + j` | 8 | `i=6`（自增），`j` 不变 | | `i + (++j)` | 9 | `i` 不变，`j=4`（自增） | --- ### 关键结论 1. **值不可能相等** 由于 `(i++) + j` 使用 `i` 的**原始值**，而 `i + (++j)` 使用 `j` 的**自增后值**，两者的计算结果必然相差 1。 2. **解析规则不可覆盖** 词法分析的"最大贪婪匹配"原则强制 `i+++j` 解析为 `(i++) + j`[^1][^4]，无法通过语法手段使其等价于 `i + (++j)`。 3. **唯一实现方式** 若需 `i + (++j)` 的语义，必须显式添加括号： ```c int result = i + (++j); // 明确前置自增 ``` ---