自增自减运算
关于自增、自减运算符使用的探讨
3自增、自减运算符运算规则的理解3.1目前出现的问题在目前大多数的教科书中。
对于自增、自减运算符的运算规则的描述通常比较简单。
论述自增、自减运算符的结合方向是“从右至左”,谈及自增、自减运算符的优先级的则是“高于算术运算”【1】。
笔者认为这种论述不够全面,会造成初学者片面的理解。
例如:main0f int a=3'b;b=++a+(++a)+(++a); q)prinf("‘a=%d,b=%dha”,a,b);b=(a++)+(a++)+(a++);②prinf(“a=%d,b=qMkn”,a,b);a=3:prinf(“a=qM,b=%dha”,a,++a+(++a)+(++a));③l若依照前述的规则,其结合性“从右至左”,自增、自减运算符的优先级高于算术运算,因此,执行完①、③后,b=6+5+4=15,a为6;而在②中,因为是后缀形式,先自身参与运算,再加1,执行后,b=5+4+3=l2,a为6;因此,可推测@『、②、③的结果分别为:a=6 b=15a=6,b=12a=6,b=1 5而实际上,程序运行以后,得到的结果是:a=6,b=18a=6,b=9a=6,b=15以上结果表明,在赋值表达式中,自增、自减运算符前缀、后缀形式所遵循的运算规则应该不同;同样,在pfinf0l~ 中,其所遵循的运算规则与前两者又有所不同。
因此.我们就以自增运算符为例,来讨论自增、自减运算符在赋值表达式中中的运算规则的理解和使用。
3.2在赋值表达式中的运算规则的使用我们知道,自增运算符若出现在变量之前(如:++i;),表示“在使用变量之前,先使变量的值加1”;若出现在变量之后f如:i++;)则表示“在使用变量之后,再使变量的值加1”.那么我们可以把语句“i=fa++)+(++b);”分解为如下3个语句:b=b+1:j=a+b;a=a+1:由此可知,前缀形式先自增1,再参与算术运算,即可理解为在赋值语句中.前缀形式运算的优先级高于算术运算;而后缀本身先参与算术运算,再自身增1,即后缀形式运算的优先级低于算术运算.因此,关于自增、自减运算符的规则我们可以理解为,在赋值语句中,自增、自减运算符若作为前缀形式,其运算优先级高于其它算术运算,即先按照“从右至左”的结合性进行自增、自减运算,再进行其它运算:若作为后缀形式,其运算优先级低于其它算术运算,即先进行其它算术运算,再按照“从右至左”的结合性进行自增、自减运算。
关于C语言中的自增.减的运算原理
C语言中的自增/自检运算原理总结自增(i++)、自减(i--)运算符的作用是使变量的值加1或减1,例如:++ i,-- i(在使用i之前,先使i值加(减)1);i++,i -- (在使用i之后,使i值加(减)1);粗略的来看,++ i和i++的作用是相当于i=i+1。
但是++i和i++的不同之处在于:++i是先执行i=i+1,再使用i的值;而i++是先使用i的值,再执行i=i+1。
如果i的原值等于3,则计算结果如下:①j=++I;(i的值先变成4,再赋给j,j的值为4)例:i=3;Printf(“%d”,++i);输出结果:4;②j=i++;(先将i的值3赋给j,j的值为3然后i变为4)例:i=3;Printf(“%d”,i++);输出结果:3;看下面程序:程序1:#include<stdio.h>void main(){int a,b;a=5;b=(a++)+(a++);printf("%d\n",a);printf("%d\n",b);}分析:a经过两次自加1的运算变成了7;然而b=(a++)+(a++);这里的a++表达式等于a不进行自加运算前的值,b相当于两个没有进行自加1运算前的值相加即:b=5+5; → b=10;程序2:#include<stdio.h>void main(){int a,b;a=5;b=(a++)+(a++)+(a++);printf("%d\n",a);printf("%d\n",b);}分析:a经过两次自加1的运算变成了8;然而b=(a++)+(a++);这里的a++表达式等于a不进行自加运算前的值,b相当于两个没有进行自加1运算前的值相加即:b=5+5+5; → b=15;a++已经介绍的差不多了,那么再说一下++a,程序3:#include<stdio.h>void main(){int a,b;a=5;b=(++a)+(++a);printf("%d\n",a);printf("%d\n",b);}分析:a的计算结果为7这个好理解,就是b值的计算,由上面的介绍可知++a是先将a的值进行自加1之后,再取出a值,这里有两个++a的运算式,即a先自加1变成7,再参与b 值的计算:b=7+7; → b=14;那么b=(++a)+(++a) +(++a);的计算结果是不是24呢?看下面的程序:程序4:#include<stdio.h>void main(){int a,b;a=5;b=(++a)+(++a)+(++a);printf("%d\n",a);printf("%d\n",b);}分析:这里的b并不等于24,而是22,之前已经计算出b=(++a)+(++a)的值为14,这时a=7,那么又经过一个(++a)式,a=8,且最后一个表达式(++a)也是等于8,则b=(7+7)+8→b=14+8; 即:b=22,那么b=(++a)+(++a)+(++a) +(++a)又等于多少呢?程序5:#include<stdio.h>void main(){int a,b;a=5;b=(++a)+(++a)+(++a)+(++a);printf("%d\n",a);printf("%d\n",b);}分析:由上面程序可知:这里的a=9,再由b=(++a)+(++a)与b=(++a)+(++a)+(++a)可得,b=(++a)+(++a)+(++a)+(++a)即:b=(7+7)+8+9,那么- -a呢?程序6:#include<stdio.h>void main(){int a,b;a=5;b=(--a)+(--a);printf("%d\n",a);printf("%d\n",b);}分析:与++a原理相同:--a这里的值为a=3,则b=3+3→b=6;那么b=(--a)+(--a) +(--a);原理与++a相同,即:b=(--a)+(--a) +(--a); → b=3+3+2; →b=8。
自增自减运算符的规则
自增自减运算符的规则
C语言提供自增运算符“++”和自减运算符“--”,这两个运算符在C语言编程中大量使用,而且使用非常灵活,需要重点理解。
首先,我们来总结这两个运算符使用的规则:
(1)、自增运算符“++”是对变量的值增加1;
(2)、自减运算符“--”是对变量的值减掉1;
(3)、参与自增运算符的变量,可以在前和在后,例如有变量int i;可以有i++和++i这样的表达式,这两种表达式都会使变量i的值增加1;而且i++表达式返回i变量自增之前的值;++i表达式是返回i变量自增之后的值。
例如有:
int i1=6;
int i2=6;
int a1=i1++;
int a2=++i2;
那么,a1变量的值是变量i1自增之前的值,所以,a1变量的值是6数值;变量a2的值是变量i2自增之后的值,所以,a2变量的值是7数值。
所以,i1++是一个表达式,如同1+2是一个算术表达式,那么,1+2算术表达式的值是3;而i1++也是一个表达式,它的表达式值是i1变化自增之前的值。
对应++i2也是一个表达式,表达式是值是i2自增之后的值。
自增自减运算符
自增自减运算符自增自减运算符,又称前置和后置运算符,是一类特殊的算术表达符号,用来对被操作数做自增或自减操作。
它有两种形式,一种为++表示自增;另一种为 --表示自减。
自增自减运算符也可以被称之为简化算术表达式”,有助于简化程序中的算术表达式,也为程序设计者提供了更多的灵活性。
二、自增自减运算符的使用(1)变量自增 1置的自增运算符 a++变量 a值增加1,即先计算 a值,然后自增1。
a++语法为: a++ ++a 。
后置的自增运算符 a--变量 a值减少1,即先计算 a值,然后自减1。
a--语法为: a-- --a 。
(2)数组自增或自减自增运算符也可以用于数组上,此时作用是使数组下标自增或自减。
前置自增运算符可以用于某个数组元素的下标,例如++array[i] 。
此运算符先将 i增1,然后返回 i指的元素的值,最终将 i向下一个元素。
而后置自增运算符 array[i]++先将 i指的元素的值返回,然后将 i增1,最终将 i向下一个元素。
三、自增自减运算符的应用(1)处理循环自增自减运算符在循环操作中广泛应用,例如,在for循环中,它们可以很方便地实现循环项之间值的增减,如下所示:for(int i=0;i<100;i++){//环体}(2)处理字符串自增自减运算符也可以用于处理字符串,例如可以使用前置运算符在字符串中查找一个字符:char c=str[0];//为str的第一个字符while(c!=0//判断当前字符是否为空字符{//其他处理c=str[++i];//使 i增}四、自增自减运算符的安全使用自增自减运算符在 C/C++程序设计语言中是非常常见的,但在使用它们时也要注意安全性,以免出现意外错误。
(1)确保变量范围当使用自增自减运算符时,要先确保变量在有效的范围内,因为它们将使变量的值超过有效范围,从而导致错误。
(2)不要傻傻滥用自增自减运算符具有优雅的表现力,但也不能滥用,否则容易导致程序混乱。
python自增自减运算符的规则
python自增自减运算符的规则Python是一种广泛使用的编程语言,它提供了丰富的运算符来进行数值计算和赋值操作。
其中,自增自减运算符是Python中常用的一种运算符,它可以方便地对变量进行自增或自减操作。
本文将介绍Python中自增自减运算符的规则,并通过示例代码进行说明。
一、自增自减运算符的概念在Python中,自增自减运算符分别为"++"和"--"。
自增运算符"++"用于将变量的值加1,自减运算符"--"用于将变量的值减1。
这两个运算符都是在变量本身的基础上进行操作,可以简化代码的书写。
二、自增自减运算符的使用规则1. 自增自减运算符只能用于数值类型的变量,包括整数类型和浮点数类型。
2. 自增自减运算符不能用于字符串类型、列表类型和元组类型等不可变类型的变量。
3. 自增自减运算符只能在赋值语句中使用,单独使用会导致语法错误。
4. 自增自减运算符可以放在变量的前面或后面,分别表示先进行运算再进行赋值,或先进行赋值再进行运算。
三、自增自减运算符的示例代码下面通过一些示例代码来演示自增自减运算符的使用规则。
1. 自增运算符的使用示例```pythona = 1a += 1print(a) # 输出:2b = 1b = b + 1print(b) # 输出:2```在上面的示例代码中,通过自增运算符"+="将变量a的值加1,结果为2。
与之等价的是通过赋值运算符"+"和加法运算符"+"实现的变量b的加法操作。
2. 自减运算符的使用示例```pythonc = 2c -= 1print(c) # 输出:1d = 2d = d - 1print(d) # 输出:1```在上面的示例代码中,通过自减运算符"-="将变量c的值减1,结果为1。
与之等价的是通过赋值运算符"-"和减法运算符"-"实现的变量d的减法操作。
C 自增运算符与自减运算符
C 自增运算符与自减运算符C语言提供了两个用于变量递增与递减的特殊运算符。
自增运算符++使其操作数递增1,自减运算符使其操作数递减1。
我们经常使用++运算符递增变量的值,如下所示:if (c = '\n')++nl;++与--这两个运算符特殊的地方主要表现在:它们既可以用作前缀运算符(用在变量前面,如++n)。
也可以用作后缀运算符(用在变量后面,如n++)。
在这两种情况下,其效果都是将变量n的值加1。
但是,它们之间有一点不同。
表达式++n先将n的值递增1,然后再使用变量n 的值,而表达式n++则是先使用变量n 的值,然后再将n 的值递增1。
也就是说,对于使用变量n的值的上下文来说,++n和n++的效果是不同的。
如果n的值为5,那么x = n++;执行后的结果是将x的值置为5,而x = ++n;将x的值置为6。
这两条语句执行完成后,变量n的值都是6。
自增与自减运算符只能作用于变量,类似于表达式(i+j)++是非法的。
在不需要使用任何具体值且仅需要递增变量的情况下,前缀方式和后缀方式的效果相同。
例如:if (c == '\n')nl++;但在某些情况下需要酌情考虑。
例如,考虑下面的函数squeeze(s, c),它删除字符串s 中出现的所有字符c:/* squeeze: delete all c from s */void squeeze(char s[], int c){int i, j;for (i = j = 0; s[i] != '\0'; i++)if (s[i] != c)s[j++] = s[i];s[j] = '\0';}每当出现一个不是c 的字符时,该函数把它拷贝到数组中下标为j 的位置,随后才将j 的值增加1,以准备处理下一个字符。
其中的if语句完全等价于下列语句:if (s[i] != c) {s[j] = s[i];j++;}我们在第1章中编写的函数getline是类似结构的另外一个例子。
自增自减运算符的运算对象
自增自减运算符的运算对象自增自减运算符是编程语言中常见的一种运算符,用于对变量进行增加或减少操作。
本文将对自增自减运算符进行详细介绍和说明。
一、自增自减运算符的概念自增自减运算符分为两种形式:前置形式和后置形式。
前置形式是在变量前面加上++或--符号,后置形式是在变量后面加上++或--符号。
自增运算符(++)用于将变量的值增加1,自减运算符(--)用于将变量的值减少1。
二、自增自减运算符的使用1. 前置形式前置形式的自增自减运算符会先对变量进行自增自减操作,然后再使用变量的值。
例如:int a = 5;int b = ++a;此时,变量a的值会先自增1,然后赋值给变量b,所以b的值为6。
2. 后置形式后置形式的自增自减运算符会先使用变量的值,然后再对变量进行自增自减操作。
例如:int a = 5;int b = a++;此时,变量a的值会先赋值给变量b,然后再自增1,所以b的值为5。
三、自增自减运算符的应用场景自增自减运算符在编程中有着广泛的应用场景,下面将介绍几个常见的应用场景。
1. 循环控制自增自减运算符可以在循环中灵活运用,实现对循环变量的控制。
例如:for (int i = 0; i < 10; i++) {// 循环体}在这个例子中,每次循环i的值都会增加1,直到i的值大于等于10时,循环结束。
2. 数组遍历自增自减运算符可以用于数组的索引控制,实现对数组元素的遍历。
例如:int[] array = {1, 2, 3, 4, 5};for (int i = 0; i < array.length; i++) {// 对数组元素进行操作}在这个例子中,通过自增运算符i的值逐渐增加,可以依次访问数组中的每个元素。
3. 递增递减操作自增自减运算符可以用于递增递减操作,实现对变量的快速增加或减少。
例如:int count = 0;count++;count--;在这个例子中,通过自增运算符count的值会增加1,通过自减运算符count的值会减少1。
c语言指针自增自减运算的含义
c语言指针自增自减运算的含义C语言中的指针自增自减运算在编程中具有非常重要的含义和作用。
通过对指针的自增自减操作,我们可以更加灵活地操作内存位置区域,实现对数据的高效访问和操作。
本文将深入探讨C语言中指针自增自减运算的含义和用法,帮助读者全面理解这一重要的概念。
一、指针的基本概念在C语言中,指针是一种非常重要的数据类型,它用来存储变量的位置区域。
通过指针,我们可以直接访问或修改变量的值,实现对内存的精准控制。
指针的自增自减运算就是针对指针变量所指向的内存位置区域进行操作,使得指针能够指向相邻的内存单元,实现对数据的高效遍历和处理。
二、指针的自增运算指针的自增运算使用”++“符号来实现,它的含义是使指针指向下一个内存单元。
如果有一个指针变量ptr,执行ptr++操作后,ptr将指向下一个内存位置区域,即ptr += sizeof(数据类型)。
这种操作在对数组进行遍历或者实现循环遍历过程中非常有用,可以快速地访问数组中的元素。
在实际编程中,指针的自增运算可以用于实现对数组的遍历、链表的操作和内存空间的动态分配等。
通过合理地使用指针的自增运算,我们可以优化程序的性能,提高数据的访问效率。
三、指针的自减运算指针的自减运算使用”--“符号来实现,它的含义是使指针指向上一个内存单元。
类似地,执行ptr--操作后,ptr将指向上一个内存位置区域,即ptr -= sizeof(数据类型)。
指针的自减运算可以用于倒序遍历数组或链表等数据结构,也可以配合动态分配的内存空间进行内存释放和管理。
在实际编程中,指针的自减运算同样具有重要的作用,它可以帮助我们在处理一些特定问题时更加灵活地操作内存位置区域,实现复杂数据结构的遍历和管理。
四、个人观点和总结作为一名程序员,深入理解指针的自增自减运算对于提高编程能力和理解计算机底层原理非常重要。
通过合理地使用指针的自增自减运算,我们可以更加高效地处理内存数据,实现对各种数据结构的操作,为程序的性能优化和功能实现提供了重要的支持。
C语言程序设计(自增、自减运算符)
3.2.2自增、自减运算符在循环结构中会经常碰到某一个变量加1再赋给变量本身的情况,如引例的i=i+1。
在c语言中有专门的运算符来表示这种情况,该运算符称为自增运算符,形式为++,含义是使变量自加1,如i++表示的含义是变量i加1再赋给本身,即i++等价于i=i+1,但前者的执行效率高于后者,跟自增运算符类似的还有自减运算符,形式为--,如i--表示变量i减1再赋给本身,即i--等价于i=i-1。
自增自减运算符是单目运算符,它们只能作用于变量。
i++和++i的区别是:i++是i 参与运算后i的值再自增1(即:先引用i,然后i的值再增1),而++i是i自增1后再参与其它运算(即:先使i的值增1,然后再引用i,)。
例如:设i的初值为5,执行完j=i++后j的值为5,i的值为6,而如果i的初值为5,执行完j=++i;后j的值为6,i的值为6。
关于i--和--i的区别同此类似。
注意:自增自减运算符不能作用于常量和表达式,比如:7++和--(a+b)都为错误表达式。
【例3-10】自增自减运算符的使用/*程序名:3_10.c*//*功能:自增自减运算符的使用*/#include<stdio.h>int main(){int i=8;printf("%d,",++i);/*打印自加后的值*/printf("%d,",--i);/*打印自减后的值*/printf("%d,",i++);/*先打印原值,后自加*/printf("%d,",i--);/*先打印原值,后自减*/printf("%d,",-i++);/*先取原值,做负运算并打印,再自加*/printf("%d\n",-i--);/*先取原值,做负运算并打印,再自减*/return0;}该程序的运行结果为:9,8,8,9,-8,-9。
C语言的自增和自减
1、自增和自减运算符是C语言中特有的一种运算符,他们的作用分别是对运算对象做加1和减1运算,其功能如下:++ 自增运算符,如:a++,++a;-- 自减运算符,如:a--,--a。
从表面上看,a++和++a的作用都是使变量a的值加1,但由于运算符++所处的位置不同,使变量a执行加1的运算过程也不同,++a的运算过程是:先使变量a执行a+1的操作,再使用a的值,a++的运算过程是:先使用变量a的值,再执行a+1的操作。
自增和自减运算符只能用于变量,不能用于常数或者表达式。
1、逗号运算符在C语言中,逗号运算符“,”可以将两个或多个表达式连接起来,称为逗号表达式。
逗号表达式的一般形式为:表达式1,表达式2,表达式3....表达式n逗号表达式的运算过程是:先运算表达式1,再计算表达式2,....以此计算到表达式n。
1、条件运算符是C语言中唯一的一个三目运算符,他要求有3个运算对象,用它可以将3个表达式连接构成一个表达式。
条件表达式的一般形式如下:表达式1?表达式2:表达式3其功能是首先计算表达式1,当其值为真(非0值)时,表达式2的值作为挣个条件表达式的值,否则将表达式3的值作为整个条件表达式的值。
C语言中共有6种位运算符,按优先级从高到低依次是:按位取反(运算符~)--左移(运算符<<)--右移(运算符>>)--按位与(运算符&)--按位异或(运算符^)--按位或(运算符|)1、c语言中的移位运算符有两种,左移运算符、右移运算符。
1)左移运算符(<<),其作用是讲一个数的各个二进制位全部左移若干位。
例如a=a<<2,表示将a的二进制数左移2位,若a=15,即二进制数00001111,左移2位得到的结果是00111100,再如a=240,即二进制数11110000,左移2位后得到的结果是11000000.其中高位左移后溢出,被舍弃了,低位以0进补。
java——算术运算符——自增自减运
java——算术运算符——⾃增⾃减运⾃增⾃减运算符
⾃增运算符:++
⾃减运算符:--
基本含义:让⼀个变量涨⼀个数字1,或者让⼀个数字降⼀个1
使⽤格式:写在变量名称之前,或者写在变量名称之后。
例如:++num,也可以num++
使⽤⽅式:
1.单独使⽤:不和其他任何操作混合,⾃⼰独⽴成为⼀个步骤。
2.混合使⽤:和其他操作混合,例如与赋值混合,或者与打印操作混合等
使⽤区别:
1.在单独使⽤的时候,前++和后++没有任何区别。
也就是:++num;和num++是完全⼀致的。
2.在混合的时候,有【重⼤区别】
A.如果是【前++】,那么变量【⽴刻马上+1】,然后拿着结果进⾏使⽤。
【先加后⽤】
B.如果是【后++】,那么⾸先使⽤变量本来的数值,【然后再让变量+1】。
【先⽤后加】注意事项:
只有变量才能使⽤⾃增、⾃减运算符。
常量不可发⽣改变,所以不能使⽤。
自增自减运算符
自增自减运算符自增自减运算符是计算机编程中常用的符号,它们分别使变量增加或减少一次预定的值。
这种运算符在大多数编程语言中都能够找到,其中最常见的是C语言。
它们可以用来减少程序员的编码工作量,提高程序的执行效率。
自增自减运算符可以说是数学中熟悉的算术运算符号的计算机程序化表达方式。
它们包括自增(++)和自减(--)两类运算符。
自增运算符号经常用来将变量的值递增1,而自减运算符则会将变量的值递减1。
很多编程语言都支持这种操作,其中C语言在其中占有主导地位。
自增自减运算符主要用于简化一些重复性的编码工作,比如对变量的运算。
例如,如果要对一个变量进行原子性的递增,我们可以使用自增运算符:int x = 0;x++;在上面的示例中,我们在变量x的基础上增加1,即x = x + 1,同时会简化减少变量值的操作,类似的,如果要减少变量值,我们可以使用自减运算符:int x = 0;x--;在这个示例中,我们同样也是对变量x递减1,即x = x - 1,两个操作都非常简单而且高效,只需要一行代码就可以完成。
此外,自增自减也常被用于循环语句中。
例如,C语言中的for 循环中经常会出现自增自减的形式:for(int i = 0; i < 10; i++){//Do something here}在上面的示例中,在循环的最后一行中会对变量i进行递增1操作,也就是将变量i的值由0递增到10,再次强调,使用自增自减运算符可以大大减少程序员编码的工作量,使程序更加简洁。
总结,自增自减运算符是编程中非常常见的符号,主要用于减少程序员编码工作量,提高程序的执行效率。
其中自增(++)和自减(--)是计算机程序中常用的运算符号,涉及到变量的加减和循环操作,经常被用于简化程序的代码,有效提高程序的执行效率。
自增、自减运算
$recPerPage 是每次查询的记录数 (即每页显示的图书数) ,它 们是 limit 字句的两个参数 ,决定每次从哪条记录开始 ,最多查 出几条记录 ,即实现分页查询 。分页查询可以提高查询速度 , 减轻服务器的负担 ,显著提高网站运行效率 ,并使浏览器显示 页面简洁美观 ,便于用户浏览 。
五 、结束语
而 + + m 3 + + m + + + m 的操作过程是 :
式求值顺序为从左到右 ,前置自增为先修改操作数使之增 1 ,增
步骤 OPTR OPND 输入字符
1 后的值作为表达式的值 。第一次做加法时 ,取的两个操作数
1
ቤተ መጻሕፍቲ ባይዱ
+ +m
为 m 增 1 再增 1 的值 ,即 5 ,故和为 10 ;当做第二个加法时 ,第
# include < iostream. h >
void main ()
{int a = 3 ,b = 5 ,c = 7 ; cout < < a < < ’\ t’< < a + + < < endl ; cout < < b < < ’\ t’< < + + b < < endl ; cout < < + + c < < ’\ t’< < c < < endl ;
指针的自增自减运算
指针的自增自减运算
在C语言中,指针的自增自减运算是对指针进行增加或减少的操作。
指针的自增运算使用++运算符,它将指针的值增加一个指针类型的步长。
例如,对一个int类型的指针p执行++p,将使p 指向下一个int类型的内存位置。
指针的自减运算使用--运算符,它将指针的值减少一个指针类型的步长。
例如,对一个int类型的指针p执行--p,将使p指向前一个int类型的内存位置。
示例代码如下:
int *p = (int *)0x1000; // 假设p指向内存地址0x1000
p++; // 将p增加一个int类型的步长,即使p指向0x1004
p--; // 将p减少一个int类型的步长,使p指向0x1000
注意,指针的自增自减操作是在指针的值上进行的,而不是改变指针所指向的内存内容。
自增自减运算也可以连续使用,如++p++或--p--,但这种使用方式并不推荐,因为它会导致代码的可读性变差。
lua 自增自减运算符
lua 自增自减运算符【原创实用版】目录1.Lua 中的自增自减运算符2.自增自减运算符的语法3.自增自减运算符的用法4.自增自减运算符的注意点正文Lua 中的自增自减运算符是一种用于增加或减少变量值的便捷方式。
这种运算符在循环和计数器等方面非常有用。
接下来,我们将详细介绍Lua 中的自增自减运算符。
自增自减运算符的语法非常简单。
它包括两个运算符:"++"和"--"。
"++"用于增加变量的值,而"--"用于减少变量的值。
这两个运算符可以放在变量前面或后面。
放在前面时,它会先增加变量的值,然后再进行其他操作。
放在后面时,它会先完成其他操作,然后再增加或减少变量的值。
例如,假设我们有一个变量 x,其值为 1。
如果我们使用"++"运算符,我们可以这样写:```x = x + 1```这将把 x 的值增加到 2。
如果我们使用"--"运算符,我们可以这样写:```x = x - 1```这将把 x 的值减少到 1。
自增自减运算符在循环和计数器方面非常有用。
例如,如果我们想要从 1 数到 10,我们可以使用"++"运算符:```for i = 1, 10 doprint(i)i = i + 1end```同样地,如果我们想要从 10 数到 1,我们可以使用"--"运算符:```for i = 10, 1 doprint(i)i = i - 1end```在使用自增自减运算符时,有一些需要注意的地方。
首先,"++"和"--"运算符的优先级相同,但是它们的结合性不同。
"++"的结合性是“后”,"--"的结合性是“前”。
这意味着在表达式中,"++"运算符会先计算其他操作,然后再增加变量的值;而"--"运算符会先增加变量的值,然后再计算其他操作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
SCAU-PPT 2013-10例题“i=3,j=i+++i+++i++”用不同的编译器得出的结果不一样,具体步骤大家可通过debug追踪分析。
先了解以下知识:
一、C语言中未定义表达式j=i+++i+++i++
未定义是ANSI C标准中并没有定义。
未定义表达式在不同的编译器下可能会给出不同的结果。
例如:
(1) TC和Turbo C的结果一样,因为二者的内核差不多,它们执行同样的原则。
(2) 由于在VC开发升级过程时,与 GCC互相借鉴,所以VC大多数情况下和GCC一样。
由于VC更主流,因此,C/C++以VC为准。
若出现类似的未定义行为的语句,按照主流的解释(所谓的主流解释,不过是臆断或者从主流编译器结果推论出来的,并不能作准),有疑惑的时候,用VC验证,符合VC就对了。
(VC结果基本上认为是标准答案,比如全国计算机等级考试C/C++语言也是用VC)
注意:标准C/C++语言中不推荐写这样的语句“j=i+++i+++i++”,玩玩可以,若做正规项目就不要用上述危险的代码。
二、C编译器的贪吃规则+求值顺序
1、贪吃规则:编译器读程序时,努力把字符拼成符号,例如“i+++i+++i++”读入过程如下:首先读入“i”,然后读入“+”,此时编译器做出判断,看接下来的一个字符能不能和前面的组成符号,发现是“+”,则继续读入“+”组成符号“++”,这就是所谓的贪吃规则。
于是,编译器把“i++”看成一个整体,整个表达式从左到右按上述方式一直读下去,最后可写成“j=(i++)+(i++)+(i++);”。
该语句以分号“;”结束,即,遇到分号时赋值结束。
例1:有同学可能要问“i=3,求i++i++i++的值”。
解释:其实,i++i++i++不对,上述写法编译器会报错。
2、求值顺序:自增运算符“++”的优先级> 算木运算符“+”的优先级。
虽然“i++”和“++i”的优先级相同,但它们同时出现时,“i++”的优先级>“++i”的优先级,关于这点大家可以通过实践去验证。
【昨天上课时,按这个规则从“i=3,j=i+++i+++i++”表达式后面开始读取,而不是像机器一样采用“贪吃规则”。
但是,作为入门级,大家按照贪吃规则。
】
我们知道,“i++”是“先用后自增”,若同一个表达式出现多个“i++”时,则一直“用”到结束判定分号“;”。
于是,对于“j=(i++)+(i++)+(i++);”,大多数C++编译器会把3作为表达式中i的值,赋值时为3+3+3;赋值后i开始自增三次为6。
类似题目,大家可用如下代码调试:
#include<stdio.h>
#include<stdlib.h>
void main()
{
int i=3;
int j=i+++i+++i++;
printf("j=%d i=%d\n",j,i);
system("pause"); \\试试和这条语句的关系getchar();
}
例2:执行以下两条语句“i=3,j=(i++)+(i++)+(++i);”之后,j=?
用VC++6.0调试看看,好像是前两项先相加,然后加第三项,结果j为10。
为什么呢?可参看第三部分习题1的参考答案,里面将详细介绍求值顺序。
三、为了进一步理解自增(自减类似)运算,完成以下习题:
——建议大家完成上述两题之后再对照参考答案。
1、以下两条语句执行完之后i=?,j=?
int i=3;
int j=(++i)+(++i)+(++i);
2、以下四条语句执行完之后i=?,j=?
int i=3,j=0;
j=(++i)+j;
j=(++i)+j;
j=(++i)+j;
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
【提示:任何一个表达式都会产生一个临时值(见教材),双目运算符“+”需两个操作数才能完成计算。
】
1.第1题:本题中的有关j的赋值表达式有3个“++i”,从左到右看:
a)首先是第一个“++i”,易知i=4(内存中变量i指向的单元中的值为4),然后遇到
“+”,因为“+”需要两个操作数才能完成运算,所以要等到“+”之后的值(即
第二个“++i”)计算完毕,根据“++i”等价于“i =i+1”,此时i由内存中的4变为
5。
至此,第一个“+”得到两个操作数(由于第一个i与第二个i是(内存中)同
一个变量,所以第一个i也是5),它才能继续计算下去。
5+5得到10,10存放于
临时变量中。
b)然后遇到第二个“+”,要等其后的“++i”计算完毕,即第三个“++i”得到i=6。
于是,第二个“+”将临时变量中的10和6相加,得到16,将其作为最后结果,
赋值给j,所以j的值为16。
2.第2题:具体每一步骤分析如下:
j=(++i)+j;
第一个j的值为0,++i后i的值为4,所以j的值为4。
j=(++i)+j;
第二个j的值为4,++i后i的值为5,所以j的值为9。
j=(++i)+j;
第三个j的值为9,++i后i的值为6,所以j的值为15。