自增运算

最新推荐文章于 2021-07-04 09:51:25 发布
原创 最新推荐文章于 2021-07-04 09:51:25 发布 · 983 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文详细解释了在C++中前置加一（++x）和后置加一（x++）运算符的执行顺序，并通过示例代码展示了它们在实际应用中的差异。理解这些差异对于编写高效且可预测的代码至关重要。

概念：

++x ：x先运行++（+1）后，再去做其他运算。

x++：x先去做其他运算，最后再自己++（+1）。


【示例】

class A{
    int x=7;
    int y=++x + (x++ + x)
    System.out.println(y);
}
结果：25

运行详细步骤：

1.执行 ++x —> 此时x变为8（因为运算中的 x 都指向同一块内存，有新的值会被覆盖）

2. [x=8] 再运算（x++ +x）中的内容 —>值为 16

3.x++ 是做完其他运算，再 ++—>此时x变为9

4.最终输出：16 + 9




【C/C++】自增运算符++详解
MeowStarPeople的博客
05-03 4043
关于 a = 2 * a++ *(3 –  ++a)的运算过程分析： 将以上源代码进行反汇编之后的结果如下：        int a = 2; 00C313DE mov         dword ptr [a],2  // a = 2;        a = 2 * a++*(3 - ++a); //++a   00C313E5  mov
用自增运算控制P0口8位LED流水花样-综合文档
05-25
这里我们探讨的主题是如何使用自增运算来控制P0口的8位LED，实现流水灯的花样效果。流水灯是LED显示中一个经典的动态效果，它通过有序地切换LED的状态，形成一种灯光流动的视觉效果。 首先，我们要了解P0口。在很多...
自 增 运 算
u013119474的专栏
03-18 512
这是为什么，i++和++i为什么不一样？ /*zizeng*/ #include void main() { int i=8; printf("%d\n",++i); printf("%d\n",--i); printf("%d\n",i++); printf("%d\n",i--); printf("%d\n",-i++)
Python：自增运算
魔筝炼药师
07-29 1120
参考：https://www.cnblogs.com/lovemdx/archive/2012/05/11/2496660.html 待更新
JAVA 自增运算
七七的博客
01-18 708
自增运算：(只能用在变量上，常量不能使用++和–) ++ 在变量原有基础上，累加一个1 -- 在变量原有基础上，累减一个1 使用格式： 用在变量前面：++num 用在变量后面：num++ 使用方式： 单独使用：自己独立成一个步骤语句，不和其他操作混合。 混合使用：和其他操作一起混合。 前和后两个使用方式区别： 单独使用：前++和后++没有任何区别。 int num1 = 1...
用自增运算控制P0口8位LED流水花样.zip
01-15
标题"用自增运算控制P0口8位LED流水花样.zip"暗示了这是一个关于使用自增运算符来实现8位LED在P0端口上的流水灯效果的教程或示例代码。 LED流水灯通常是通过编程控制单片机的IO口来实现的。在这个例子中，使用的...
单片机课程设计——用自增运算控制P0口8位LED流水花样.zip
09-21
在本次的单片机课程设计中，我们关注的是如何利用自增运算来控制P0口的8位LED流水灯花样。这项设计基于AT89S52单片机，并使用C语言进行编程，旨在帮助学习者掌握单片机基本操作、C语言在硬件控制上的应用以及自增...
用自增运算控制P0口8位LED流水花样
03-15
标题中的“用自增运算控制P0口8位LED流水花样”揭示了这个项目的核心内容。这涉及到嵌入式系统编程，尤其是针对51系列单片机的编程，以及LED显示技术。在51单片机中，P0口是一个八位双向数据总线，可以用来驱动外部...
最新单片机仿真 用自增运算控制P0口8位LED流水花样
05-21
最新单片机仿真 用自增运算控制P0口8位LED流水花样最新单片机仿真 用自增运算控制P0口8位LED流水花样最新单片机仿真 用自增运算控制P0口8位LED流水花样最新单片机仿真 用自增运算控制P0口8位LED流水花样最新单片机...
Java基础之自增运算
Calarqiang的博客
07-04 3954
对于Java里面的自增说明 自增分为前自增和后自增，也就是常说的前加加和后加加。它们作为单目运算符，作用在不同类型的变量类型身上会有不同的效果。 共性：它们最后的结果都会使变量对应的值进行加一操作。 区别：如果结合赋值运算符进行运算时，前自增是先将变量对于的值加一之后，然后再进行赋值操作。而后自增则是先将变量对应的值进行赋值操作，然后再进行加一的操作。 由于对特定类型进行自增操作，会存在一个强制类型转换问题，因此当某一个类型进行自增操作时，结果应该用相同类型的变量来进行接收。 1. 对于整数类型
关于自增符的运算
zsX1ao的博客
12-16 569
首先，自增分为前缀和后缀：++i和i++。 在单独成式的情况下，两者并没有什么区别，都是把i+1的值赋给i 但在表达式中，两者有明显的区别。 例如
（C++）浅谈自增运算
wangshu214的博客
07-19 3600
一、介绍 说起自增运算（我以前称它为自加运算，其实也差不多~~）大家一定知道就是形如“i++”形式的表达式，相信编程书上也是这么介绍的。我之前学习C#，唯一使用i++的机会就是循环的时候，自变量+1。其实过了很久我才只知道"++"不仅可以放在变量的前面而且也可以放在变量的后面现在我就开始揭开它的神秘面纱！ 二、定义 首先自增运算符有前置和后置之分。前置“++变量”：它就相当于变量
C语言 自增（++）、自减（--）运算
热门推荐
看花容易绣花难
02-03 1万+
1.作用 自增运算使单个变量的值增１，自减运算使单个变量的值减１。 2.用法与运算规则 自增、自减运算符都有两种用法： （1）前置运算──运算符放在变量之前：＋＋变量、－－变量 先使变量的值增（或减）１，然后再以变化后的值参与其它运算，即先增减、后运算。 （2）后置运算──运算符放在变量之后：变量＋＋、变量－－ 变量先参与其它运算，然后再使变量的值增（或减）１，即先运算、后增减。 [案例] 自增、...
自增运算符、位运算符与条件运算符
若凡~~~
01-15 276
自增运算符 a=1; b=a++; //则相当于 a=1; b=a; a=a+1; //先赋值，再自增 a=1; b=++a; //则相当于 a=1; a=a+1; b=a; //先自增，再赋值 位运算符 位运算符含&、|、^、~、<<、>> A=0011 1100 B=0000 1101 A&B=0000 1100 //&:该位都是1的时候，得1；否则得0 A|B=0011 1101 //|:该位含有1的时候，的0；否则得1 A^B=0
自增运算符总结（最通俗易懂）
weixin_43986850的博客
02-14 3190
自增自减运算符总结 **前言：**自增（减）运算符也是面试常常会考到的问题，也是同学常常容易出错的地方，现结合优质的视频在这里对该知识点进行笔记。 两种情况： 1.单独使用时 a++与++a结果没有区别 可以发现运算结果是一样的 2.混合使用时 如赋值或者打印时 (1) int a = i++; 与 int a = ++i; (2) System.out.println(i++); 与 System.out.println(++i); 存在重大区别 如果是前++，那么变量立刻+1，
自增运算符 i++，++i 详解
yumoshengyan的博客
03-07 1990
    粗略地看，++i和i++的作用都是 i = i+1.但他们两兄弟之间还是有差距的。就是在于执行与使用的先后顺序，注意：执行与使用。#include&lt;stdio.h&gt; int main() { int i = 0; printf("当前 i=%d\t",i); printf("执行 i=%d\t",i++); printf("使用 i=%d\n",i); pr...
自增运算与自减运算
fancy161的专栏
03-19 574
1. 自增运算符（Increment Operator）    自增运算符 ++ 使操作数的值增 1，其操作数必须为可变左值（您可以简单地把可变左值理解为变量）。++ 可以置于操作数前面，也可以放在后面。例如：        ++n ;        n++ ;这两个语句产生的结果都是使 n 增 1，可以说没什么区别。使用以下语句得到的效果也是一样的：        n = n +
自增运算符的用法
u013452990的博客
04-13 1045
a++和++a 都属于自增运算符。a++是先进行取值，后进行自增。++a是先进行自增，后进行取值。
C++指针自增运算与其他内置类型的自增运算是否相同
最新发布
12-21
<think>我们正在讨论指针的自增运算与其他内置类型（如int）的自增运算是否相同。 根据用户提供的引用内容，我们可以总结如下： 引用[1]指出：指针的自增运算是在当前地址的基础上，自增指针所指向类型的大小。即：$p = p + 1 \times \text{sizeof(类型)}$。 引用[2]也指出：指针的自增表示指针向前移动一个数据类型长度的存储单元。 引用[3]进一步说明：指针的自增自减运算与指针变量的类型密切相关，因为指针移动的字节数由类型决定。 而对于内置类型（如int、char等）的自增运算，例如： int a = 0; a++; 这里，a的值增加1（即增加一个单位，这个单位就是该类型的一个单位，对于int通常是增加1，但实际数值上增加1，而不是字节数）。 因此，指针的自增运算与其他内置类型的自增运算在语义上有所不同： - 指针的自增：增加的是地址值，且增加的量是指针所指向类型的大小（字节数）。 - 内置类型的自增：增加的是该类型的一个单位（数值上增加1，但注意对于整型是数值加1，对于字符型是ASCII码值加1，但都是数值意义上的增加，与地址无关）。 但是，从运算符的形式上看，它们都使用相同的运算符（++），并且都是将变量的值增加（或减少）一个单位。这个“单位”对于指针是类型大小，对于普通内置类型是1（数值意义上）。所以，我们可以说： 相同点： 1. 语法形式相同：都使用`++`运算符。 2. 都是将变量的值改变（增加）一个单位（尽管单位不同）。 不同点： 1. 指针自增的单位是指针所指向类型的大小（字节数），而内置类型自增的单位是1（数值上）。 2. 指针自增改变的是内存地址，而内置类型自增改变的是数值。 另外，引用[4]提到：在复杂表达式（如输出语句中）使用指针自增时，要注意运算顺序和优先级问题。因为自增运算符（尤其是后置自增）的副作用发生时间点可能随编译器实现不同而有差异，这同样适用于内置类型的自增运算。所以，在这一点上，指针自增和内置类型自增面临相同的注意事项。 结论：C++指针的自增运算与其他内置类型的自增运算在语法形式上相同，但运算的实质（增加的单位）不同。指针自增是按类型大小增加地址值，而内置类型自增是数值增加1。此外，在表达式求值顺序上，它们都遵循相同的优先级和结合性规则，但要注意副作用发生的时机。 下面用代码示例说明： 示例1：内置类型自增 ```cpp int a = 0; a++; // a变成1 ``` 示例2：指针自增 ```cpp int arr[3] = {10,20,30}; int *p = arr; // p指向arr[0] p++; // 现在p指向arr[1]，因为int类型通常占4字节，所以p的值增加了4（字节） ``` 注意：指针自增的步进大小取决于指向的类型。例如，如果p是char*类型，则自增一次增加1字节；如果是double*类型，则自增一次增加8字节（取决于系统）。 因此，在使用指针自增时，一定要清楚指针指向的类型。 最后，关于优先级和结合性，自增运算符（++）的优先级高于解引用运算符（*），所以： *p++ 等价于 *(p++) ：先进行指针自增，然后返回自增前指针指向的值（注意：这里自增运算后，指针已经指向下一个元素，但表达式的结果是自增前指针指向的值）。 对于内置类型，类似地： int a = 5; int b = a++; // b得到5，然后a变成6 所以，在表达式求值的行为上，指针自增和内置类型自增是类似的（都遵循后置自增的规则：先使用原值，再自增）。 但是，指针自增由于涉及地址的跳跃，所以必须确保指针指向的是数组元素（或数组尾后的位置），否则可能引发未定义行为。 总结：指针的自增和内置类型的自增在语法和表达式行为上相似，但指针自增的单位是指向类型的大小，而内置类型自增的单位是1（数值上）。同时，指针自增需要保证指向合法的内存区域（如数组内）。 §§相关问题§§ 1. 指针自增运算与整数自增运算在汇编层面有何区别？ 2. 如何避免指针自增导致的越界问题？ 3. C++中指针自增和迭代器自增有什么异同？ </think> ### C++指针自增运算与其他内置类型自增运算的异同 #### 1. **核心差异：运算本质** - **指针自增**： - 增加值为**数据类型大小**（步进单位由指针类型决定） - 满足公式：$p = p + \text{sizeof}(T)$，其中 $T$ 是指向的数据类型[^1][^2] - 示例： ```cpp int arr[3] = {10, 20, 30}; int* p = arr; // p=0x1000 p++; // p=0x1004 (int类型通常占4字节) ``` - **内置类型自增**： - 增加值为**固定数值1**（与类型大小无关） - 满足公式：$x = x + 1$ - 示例： ```cpp int a = 5; a++; // a=6 ``` #### 2. **相同点** | 特性 | 指针自增 | 内置类型自增 | 说明 | |--------------|----------|--------------|------| | 运算符 | `++` | `++` | 相同语法形式 | | 前置/后置语义 | 支持 | 支持 | `++p`与`p++`行为一致 | | 优先级 | 相同 | 相同 | 均高于解引用`*`等运算符[^4] | | 副作用 | 修改原值 | 修改原值 | 都会改变变量本身 | #### 3. **关键区别** | 特性 | 指针自增 | 内置类型自增 | |--------------|---------------------------|--------------------| | **运算单位** | 数据类型大小（字节） | 固定值1 | | **类型依赖** | 完全依赖指针声明类型[^3] | 与类型无关 | | **内存影响** | 改变内存地址指向 | 仅改变数值 | | **越界风险** | 高风险（可能非法访问） | 无风险 | #### 4. **特殊场景分析** - **数组遍历对比**： ```cpp // 指针自增遍历 int arr[] = {1, 2, 3}; for(int* p = arr; p < arr+3; p++) { cout << *p; // p每次增加sizeof(int) } // 整数自增遍历 for(int i = 0; i < 3; i++) { cout << arr[i]; // i每次增加1 } ``` - **复合表达式中的陷阱**： ```cpp int arr[] = {10, 20}; int* p = arr; cout << *p++; // 输出10 (p先取值后自增) cout << *p; // 输出20 int a = 5; cout << a++; // 输出5 (先取值后自增) ``` #### 5. **底层原理** - **指针自增的机器码**： ```assembly mov eax, [p] ; 加载指针 add eax, 4 ; 增加sizeof(int)=4 (x86) mov [p], eax ; 存回指针 ``` - **整数自增的机器码**： ```assembly mov eax, [a] ; 加载整数 inc eax ; 直接加1 mov [a], eax ; 存回整数 ``` > **结论**： > 指针自增和内置类型自增虽然语法相同，但**本质完全不同**。指针自增是地址运算（步进值=类型大小），内置类型自增是数值运算（固定+1）。指针自增需要严格防范越界，而内置类型自增只需注意数值范围。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值