有些运算符在JAVA语言中存在着，但是在实际开发中我们或许很少用到它们，在面试题中却时常出现它们的身影，对于这些运算符的含义和用法，你是否还记得呢？
自增（++）和自减（--）运算符
我们先来回答几个问题吧：
Java代码
1.int i = 0;
2.int j = i++;
3.int k = --i;
这段代码运行后，i等于多少？j等于多少？k等于多少？太简单了？好，继续：
Java代码
1.int i = 0;
2.int j = i++ + ++i;
3.int k = --i + i--;
代码执行后i、j、k分别等于多少呢？还是很简单？好，再继续：
Java代码
1.int i=0;
2.System.out.println(i++);
这段代码运行后输出结果是什么？0？1？
Java代码
1.float f=0.1F;
2.f++;
3.double d=0.1D;
4.d++;
5.char c='a';
6.c++;
上面这段代码可以编译通过吗？为什么？如果你能顺利回答到这里，说明你对自增和自减运算符的掌握已经很好了。
为了分析出上面提出的几个问题，我们首先来回顾一下相关知识：
?自增（++）：将变量的值加1，分前缀式（如++i）和后缀式（如i++）。
前缀式是先加1再使用；后缀式是先使用再加1。
?自减（--）：将变量的值减1，分前缀式（如--i）和后缀式（如i--）。
前缀式是先减1再使用；后缀式是先使用再减1。
在第一个例子中，int j=i++;是后缀式，因此i的值先被赋予j，然后再自增1，所以这行代码运行后，i=1、j=0；而int k=--i;是前缀式，因此i先自减1，然后再将它的值赋予k，因此这行代码运行后，i=0、k=0。
在第二个例子中，对于int j=i++ + ++i;，首先运行i++，i的值0被用于加运算（+），之后i自增值变为1，然后运行++i，i先自增变为2，之后被用于加运算，最后将i两次的值相加的结果1+2=3赋给j，因此这行代码运行完毕后i=2、j=3；对于int k=--i + i--;用一样的思路分析，具体过程在此不再赘述，结果应该是i=0、k=2。
自增与自减运算符还遵循以下规律：
1.可以用于整数类型byte、short、int、long，浮点类型float、double，
以及字符串类型char。
2.在Java5.0及以上版本中，它们可以用于基本类型对应的包装器类Byte、
Short、Integer、Long、Float、Double、Character。
3.它们的运算结果的类型与被运算的变量的类型相同。
下面的这个例子验证以上列出的规律，它可以编译通过并执行。
Java代码
1.public class Test {
2. public static void main(String[] args) {
3. // 整型
4. byte b = 0;
5. b++;
6. // 整型
7. long l = 0;
8. l++;
9. // 浮点型
10. double d = 0.0;
11. d++;
12. // 字符串
13. char c = 'a';
14. c++;
15. // 基本类型包装器类
16. Integer i = new Integer(0);
17. i++;
18. }
19.}
按位运算符
你还能说出来按位运算符一共有哪几种吗？对比下面的列表看看，有没有从你的记忆中消失了的：
1.按位与运算（&）：二元运算符。当被运算的两个值都为1时，运算结果
为1；否则为0。
2.按位或运算（|）：二元运算符。当被运算的两个值都为0时，运算结果
为0；否则为1。
3.按位异或运算（^）：二元运算符。当被运算的两个值中任意一个为1，
另一个为0时，运算结果为1；否则为0。
4.按位非运算（~）：一元运算符。当被运算的值为1时，运算结果为0；
当被运算的值为0时，运算结果为1。
这里不像我们看到的逻辑运算符（与运算&&、或运算||、非运算！）操作的是布尔值true或false，或者是一个能产生布尔值的表达式；“按位运算符”所指的“位”就是二进制位，因此它操作的是二进制的0和1。在解释按位运算符的执行原理时，我们顺便说说它们和逻辑运算符的区别。
[list=1]
逻辑运算符只能操作布尔值或者一个能产生布尔值的表达式；按位运算符能操作整型值，包括byte、short、int、long，但是不能操作浮点型值（即float 和double），它还可以操作字符型（char）值。按位运算符不能够操作对象，但是在Java5.0及以上版本中，byte、short、int、long、char所对应的包装器类是个例外，因为JAVA虚拟机会自动将它们转换为对应的基本类型的数据。下面的例子验证了这条规律：
Java代码
1.public class BitOperatorTest {
2. public static void main(String[] args) {
3. // 整型
4. byte b1 = 10, b2 = 20;
5. System.out.println("(byte)10 & (byte)20 = " + (b1 & b2)
);
6. // 字符串型
7. char c1 = 'a', c2 = 'A';
8. System.out.println("(char)a | (char)A = " + (c1 | c2));
9. // 基本类型的包装器类
10. Long l1 = new Long(555), l2 = new Long(666);
11. System.out.println("(Long)555 ^ (Long)666 = " + (l1 ^ l
2));
12. // 浮点型
13. float f1 = 0.8F, f2 = 0.5F;
14. // 编译报错，按位运算符不能用于浮点数类型
15. // System.out.println("(float)0.8 & (float)0.5 = " + (f
1 & f2));
16. }
17.}
运行结果：
?(byte)10 & (byte)20 = 0
?(char)a | (char)A = 97
?(Long)555 ^ (Long)666 = 177
?逻辑运算符的运算遵循短路形式，而按位运算符则不是。所谓短路就是一旦能够确定运算的结果，就不再进行余下的运算。下面的例子更加直观地展现了短路与非短路的区别：
Java代码
1.public class OperatorTest {
2. public boolean leftCondition() {
3. System.out.println("执行-返回值:false;方
法:leftCondition()");
4. return false;
5. }
6.
7. public boolean rightCondition() {
8. System.out.println("执行-返回值:true;方
法:rightCondition()");
9. return true;
10. }
11.
12. public int leftNumber() {
13. System.out.println("执行-返回值:0;方
法:leftNumber()");
14. return 0;
15. }
16.
17. public int rightNumber() {
18. System.out.println("执行-返回值:1;方
法:rightNumber()");
19. return 1;
20. }
21.
22. public static void main(String[] args) {
23. OperatorTest ot = new OperatorTest();
24.
25. if (ot.leftCondition() && ot.rightCondition()) {
26. // do something
27. }
28. System.out.println();
29.
30. int i = ot.leftNumber() & ot.rightNumber();
31. }
32.}
运行结果：
?执行-返回值:false;方法:leftCondition()
?
?执行-返回值:0;方法:leftNumber()
?执行-返回值:1;方法:rightNumber()
运行结果已经很明显地显示了短路和非短路的区别，我们一起来分析一下产生这个运行结果的原因。当运行“ot.leftCondition() && ot.rightCondition()”时，由于方法leftCondition()返回了false，而对于“&&”运算来说，必须要运算符两边的值都为true时，运算结果才为true，因此这时候就可以确定，不论rightCondition()的返回值是什么，“ot.leftCondition() &&
ot.rightCondition()”的运算值已经可以确定是false，由于逻辑运算符是短路的形式，因此在这种情况下，rightCondition()方法就不再被运行了。
而对于“ot.leftNumber() & ot.rightNumber()”，由于“leftNumber()”的返回值是0，对于按位运算符“&”来说，必须要运算符两边的值都是1时，运算结果才是1，因此这时不管“rightNumber()”方法的返回值是多少，
“ot.leftNumber() & ot.rightNumber()”的运算结果已经可以确定是0，但是由于按位运算符是非短路的，所以rightNumber()方法还是被执行了。这就是短路与非短路的区别。
[/list]
移位运算符
移位运算符和按位运算符一样，同属于位运算符，因此移位运算符的位指的也是二进制位。它包括以下几种：
1.左移位（<<）：将操作符左侧的操作数向左移动操作符右侧指定的位数。
移动的规则是在二进制的低位补0。
2.有符号右移位（>>）：将操作符左侧的操作数向右移动操作符右侧指定的
位数。移动的规则是，如果被操作数的符号为正，则在二进制的高位补0；
如果被操作数的符号为负，则在二进制的高位补1。
3.无符号右移位（>>>）：将操作符左侧的操作数向右移动操作符右侧指定
的位数。移动的规则是，无论被操作数的符号是正是负，都在二进制位的高位补0。
注意，移位运算符不存在“无符号左移位（<<<）”一说。与按位运算符一样，移位运算符可以用于byte、short、int、long等整数类型，和字符串类型char，但是不能用于浮点数类型float、double；当然，在Java5.0及以上版本中，移位运算符还可用于byte、short、int、long、char对应的包装器类。我们可以参照按位运算符的示例写一个测试程序来验证，这里就不再举例了。
与按位运算符不同的是，移位运算符不存在短路不短路的问题。
写到这里就不得不提及一个在面试题中经常被考到的题目：
引用
请用最有效率的方法计算出2乘以8等于几？
这里所谓的最有效率，实际上就是通过最少、最简单的运算得出想要的结果，而移位是计算机中相当基础的运算了，用它来实现准没错了。左移位“<<”把被操作数每向左移动一位，效果等同于将被操作数乘以2，而2*8=（2*2*2*2），就是把2向左移位3次。因此最有效率的计算2乘以8的方法就是“2<<3”。
C语言自增、自减运算符使用中应注意的问题 ++x 表示取x的地址，增加它的内容，然后把值放在寄存器中； x++ 则表示取x地址，把它的值装入寄存器中，然后增加内存中x的值。 在程序设计中，经常遇到“i=i+1”和“i=i-1”这两种极为常用的操作。变量i被称为“计数器”，用来记录完成某一操作的次数。C语言为这种计数器操作提供了两个更为简洁的运算符，即++和--，分别叫做自增运算符和自减运算符。它们是从右向左结合的一元算术运算符，优先级为2。学习和应用这两个运算符时应注意以下几点： 1注意表达式的值和变量值的区别 以自增运算符为例，当自增运算符++作用于一个变量时，例如：当i=3时++i这个算术表达式的值为4，同时变量i的值也由原来的3改变为4。一般情况下，计算表达式后不改变变量本身的值，而++运算符和--运算符组成的表达式计算后，则改变变量的值，这称为运算符的副作用。这类运算符在计算表达式时，一定要注意区分表达式的值和变量的值。后面有阐述注意表达式的值和变量值的区别） 2注意前缀运算和后缀运算的区别 仍以自增运算符为例，该运算符可作用在变量之前，例如前面所讲的++i，称为前缀运算；也可作用在变量之后，例如i++，称为后缀运算。在这两种运算中，表达式的值不同：前缀运算后，表达式的值为原变量值加1；后缀运算后，表达式的值仍为原变量值；（也就是我给你说的作为表达式的一部分） int m=1; printf("%d",m++);结果为 1（我给你讲输出的是m本身，表达式的值仍为原变量值） int m=1; m=m++; printf("%d",m);
值为2（这是变量的值，你会问什么时候是变量，像m++单独用是为表达式，在其他式子中是变量如m=1时，m=5+（m++）结果为7）（先把m++的值传给m，然后m再+1，若把原式写为）int n，m=1; n=m++; printf("%d",n);值是不一样的，输出为1。 而变量值不论前缀运算还是后缀运算都加1。自减运算符与自增运算符类似，只要将加1改为减1即可。即前缀运算是“先变后用”，而后缀运算是“先用后变”。（不知你懂不懂啊！） 3注意运算符的运算对象 自增、自减运算符只能作用于变量，而不能作用于常量或表达式。因为自增、自减运算符具有对运算量重新赋值的功能，而常量、表达式无存储单元可言，当然不能做自增、自减运算。只要是标准类型的变量，不管是整型、实型，还是字符型、枚举型都可以作为这两个运算符的运算对象。如以下四个表达式都是合法的：i+++j++、++i+(++j)、++a+b++、++array［--j］；而++6、(i+j)++、…A?++、++i+++j、(&p)++这五个表达式却是不合法的。为什么i+++j++合法，而++i+++j却不合法?C的编译器对程序编译时，从左到右尽可能多地将字符组合成一个运算符或标识符，因此i+++j++等效于(i++)+(j++)，两个“++”作用的对象都是变量，这是合法的；而++i+++j等效于++(i++)+j,第1个“++”作用的对象是表达式“i++”，这是不允许的。 4注意运算符的结合方向 表达式k=-i++等效于k=(-i)++还是k=-(i++)?因为负号运算符和自增运算符优先级相同，哪一个正确就得看结合方向。自增、自减运算符及负号运算符的结合方向是从右向左。因此，上式等效于k=-(i++)；若i=5，则表达式k=-i++运算之后k的值为-5，i 的值为6。此赋值表达式的值即为所赋的值-5。不要因为k=-i++等效于k=-(i++)就先做“++”运算!这里采用的是“先用后变”，即先拿出i的值做负号“-”运算，把这个值赋给变量k之后变量i才自增。
C++ 运算符大全与详解 1. 运算符与运算值的解释 运算符与运算值是构成一道计算题的主要元素，所谓的运算符,指的是 +,- ， *，/.... 等运算符号。运算值就是运算符操作的资料，例如：1+2 中， 1 和 2 都是运算值。 2. 一级运算符与二级运算符 一个运算符计算时，操作两个运算值，称为二级运算符，例如1+2 ，操作 1 和2这两个运算值，执行相加操作。如此类推，操作一个运算值的将称为一级运 算符，而一级运算符是“ -”号，相信学过数学的都知道，这个叫做负号，令其 数字变成负值，例如：-1 ，如同上列所说，只操作一个运算值。 3.运算公式 运算公式是由运算符与运算值结合的公式叫做运算公式，作用是依照指定的运 算值进行运算符的计算。例子如下 : Int a,b,c; //声明三个整数变量b=10; //给b赋值10 C=1; //给c赋值1 A=b+c; //b+c的结果赋值给 a //注意， C++ 大小写是有区分的，由于 wps 的关系，自动大写了，我也不太会用wps 这些工作软件 4.运算符的顺序 运算公式中预算符的计算顺序，称为运算符的顺序，比如在日常生活数学老师 和我们说，先乘除后加减，运算符的优先顺序我会在后文排序出表格。 5.运算符的结合 一个运算公式内，运算符顺序相同时，按照一般的计算规律，有从左到右和从 右到左两种顺序，以加减运算为例子，2+3-4 中先计算 2+3 ，之后用 2+3 的
和减去 4 ，5-4 ，有关规律请参照后文。 2.1 运算符 2.2 “=”运算符的解释 在学生时代，老师对我们说，“=”号是等于的作用，但是在程序当中，“ =”号的功能会和老师所说的“等于”不同，所有，我们不能以“等于”这个观点去 理解程序的“ =”号。 请看如下代码 : Int a,b,c; B=1; c=2; A=b+c; 以上代码的意思是如果使用“等于”观念来思考，可能觉得没什么差别，就是 位置改变了。 请看如下代码： Int a; A=a+1; 当看了此段代码，你在用“等于”观念来思考，你会觉得，一切都觉得很奇怪。 这时候你就应该用程序的观念去思考这段代码。 现在，我很大家说明程序的“=”号，在你宣告一个变量时，那个变量就是你系 统内存里面的一小部分，但是我们如何输入一些信息到变量呢? 这时候我们需要“ =”号，例如a=1;就是把数字1放进了变量 a 里面，所以“ =”号起的作用是赋值，例如小明给小红一支笔。因此，“等于”观念的“ =”号和程序里的“=”号是不同的。 2.3 算数运算符 运算符号名称运算规律程序例子实例+加法从左到右 A + B 7 + 2 -减
C语言运算符大全C语言的内部运算符很丰富，运算符是告诉编译程序执行特定算术或逻辑操作的符号。C语言有三大运算符：算术、关系与逻辑、位操作。另外，C还有一些特殊的运算符，用于完成一些特殊的任务。 表2-5列出了C语言中允许的算术运算符。在C语言中，运算符“+”、“－”、“*”和“/”的用法与大多数计算机语言的相同，几乎可用于所有C语言内定义的数据类型。当“/”被用于整数或字符时，结果取整。例如，在整数除法中，10/3=3。 一元减法的实际效果等于用-1乘单个操作数，即任何数值前放置减号将改变其符号。模运算符“%”在C 语言中也同它在其它语言中的用法相同。切记，模运算取整数除法的余数，所以“%”不能用于float和double类型。 最后一行打印一个0和一个1，因为1/2整除时为0，余数为1，故1%2取余数1。 C语言中有两个很有用的运算符，通常在其它计算机语言中是找不到它们的—自增和自减运算符，++和--。运算符“++”是操作数加1，而“--”是操作数减1，换句话说：x=x+1;同++x;x=x-1;同--x; 自增和自减运算符可用在操作数之前，也可放在其后，例如：x=x+1；可写成++x；或x++；但在表达式中这两种用法是有区别的。自增或自减运算符在操作数之前，C语言在引用操作数之前就先执行加1或减1 操作；运算符在操作数之后，C语言就先引用操作数的值，而后再进行加1或减1操作。请看下例： x=10; ;y=++x;
此时，y=11。如果程序改为： x=10;y=x++; 则y=10。在这两种情况下，x都被置为11，但区别在于设置的时刻，这种对自增和自减发生时刻的控制是非常有用的。在大多数C编译程序中，为自增和自减操作生成的程序代码比等价的赋值语句生成的代码 要快得多，所以尽可能采用加1或减1运算符是一种好的选择。 。下面是算术运算符的优先级： ：最高++、- -- -（一元减） *、/、%最低+、-编译程序对同级运算符按从左到右的顺序进行计算。当然，括号可改变计算顺序。C语言 处理括号的方法与几乎所有的计算机语言相同：强迫某个运算或某组运算的优先级升高。 关系运算符中的“关系”二字指的是一个值与另一个值之间的关系，逻辑运算符中的“逻辑”二字指的是连接关系的方式。因为关系和逻辑运算符常在一起使用，所以将它们放在一起讨论。关系和逻辑运算符概念中的关键是True（真）和Flase（假）。C语言中，非0为True，0为Flase。使用关系或逻辑运算符的表达式对Flase和Ture分别返回值0或1(见表2-6)。 表2-6给出于关系和逻辑运算符，下面用1和0给出逻辑真值表。关系和逻辑运算符的优先级比算术运算符低，即像表达式10>1+12的计算可以假定是对表达式10>(1+12)的计算，当然，该表达式的结果为Flase。在一个表达式中允许运算的组合。例如： 10>5&&!(10<9)||3<=4 这一表达式的结果为True。
自增自减 1、下列关于单目运算符++、--的叙述中正确的是 A)它们的运算对象可以是任何变量和常量 B)它们的运算对象可以是char型变量和int型变量，但不能是float型变量 C)它们的运算对象可以是int型变量,但不能是double型变量和float型变量 D)它们的运算对象可以是char型变量、int型变量和float型变量 2、设有以下定义 int a=0; double b=1.25; char c=’A’; #define d 2 则下面语句中错误的是 A) a++; B) b++; C) c++; D) d++; 3、以下选项中，与k=n++完全等价的表达式是 A) k=n,n=n+1 B) n=n+1,k=n C) k=++n D) k+=n+1 4、设正x、y均为整型变量，且x=10 y=3，则以下语句的输出结果是 printf("%d,%d\n",x--,--y); A) 10,3 B) 9,3 C) 9,2 D)10,2 5、设有 int x=11; 则表达式 (x++ * 1/3) 的值是 A) 3 B) 4 C) 11 D) 12 6、以下程序的输出结果是。 #include main() {int i=010 ,j = 10; printf("%d,%d\n",+ +i , j - -); } A) 11,10 B) 9,10 C) 010,9 D) 10,9 7、有以下程序 main() {int m=12,n=34; printf("%d%d",m++,++n); printf("%d%d\n",n++,++m); } 程序运行后的输出结果是 A)12353514 B)12353513 C)12343514 D)12343513 8、有以下程序 main() { int m=3,n=4,x; x=-m++; x=x+8/++n; printf("%d\n",x); } 程序运行后的输出结果是 A) 3 B) 5 C) -1 D) -2
C语言运算符大全 C语言的内部运算符很丰富，运算符是告诉编译程序执行特定算术或逻辑操作的符号。C语言有三大运算符：算术、关系与逻辑、位操作。另外，C还有一些特殊的运算符，用于完成一些特殊的任务。 2.6.1算术运算符 表2-5列出了C语言中允许的算术运算符。在C语言中，运算符“+”、“－”、“*”和“/”的用法与大多数计算机语言的相同，几乎可用于所有C语言内定义的数据类型。当“/”被用于整数或字符时，结果取整。例如，在整数除法中，10/3=3。 一元减法的实际效果等于用-1乘单个操作数，即任何数值前放置减号将改变其符号。模运算符“%”在C语言中也同它在其它语言中的用法相同。切记，模运算取整数除法的余数，所以“%”不能用于float和double类型。 最后一行打印一个0和一个1，因为1/2整除时为0，余数为1，故1%2取余数1。 2.6.2自增和自减 C语言中有两个很有用的运算符，通常在其它计算机语言中是找不到它们的—自增和自减运算符，++和--。运算符“++”是操作数加1，而“--”是操作数减1，换句话说：x=x+1;同++x;x=x-1;同--x; 自增和自减运算符可用在操作数之前，也可放在其后，例如：x=x+1；可写成++x；或x++；但在表达式中这两种用法是有区别的。自增或自减运算符在操作数之前，C语言在引用操作数之前就先执行加1或减1操作；运算符在操作数之后，C语言就先引用操作数的值，而后再进行加1或减1操作。请看下例： x=10; ;y=++x; 此时，y=11。如果程序改为： x=10;y=x++; 则y=10。在这两种情况下，x都被置为11，但区别在于设置的时刻，这种对自增和自减发生时刻的控制是非常有用的。在大多数C编译程序中，为自增和自减操作生成的程序代码比等价的赋值语句生成的代码 要快得多，所以尽可能采用加1或减1运算符是一种好的选择。 。下面是算术运算符的优先级： ：最高++、- -- -（一元减） *、/、%最低+、-编译程序对同级运算符按从左到右的顺序进行计算。当然，括号可改变计算顺序。C语言 处理括号的方法与几乎所有的计算机语言相同：强迫某个运算或某组运算的优先级升高。 2.6.3关系和逻辑运算符 关系运算符中的“关系”二字指的是一个值与另一个值之间的关系，逻辑运算符中的“逻辑”二字指的是连接关系的方式。因为关系和逻辑运算符常在一起使用，所以将它们放在一起讨论。关系和逻辑运算符概念中的关键是True（真）和Flase（假）。C语言中，非0为True，0为Flase。使用关系或逻辑运算符的表达式对Flase和Ture分别返回值0或1(见表2-6)。
C++运算符大全与详解 1.运算符与运算值的解释 运算符与运算值是构成一道计算题的主要元素，所谓的运算符,指的是+,-，*，/....等运算符号。运算值就是运算符操作的资料，例如：1+2 中，1和2都是运算值。 2.一级运算符与二级运算符 一个运算符计算时，操作两个运算值，称为二级运算符，例如 1+2 ，操作1和2这两个运算值，执行相加操作。如此类推，操作一个运算值的将称为一级运算符，而一级运算符是“-”号，相信学过数学的都知道，这个叫做负号，令其数字变成负值，例如：-1 ，如同上列所说，只操作一个运算值。 3.运算公式 运算公式是由运算符与运算值结合的公式叫做运算公式，作用是依照指定的运算值进行运算符的计算。例子如下: Int a,b,c; //声明三个整数变量 b=10; //给b赋值10 C=1; //给c赋值1 A=b+c; //b+c的结果赋值给a //注意，C++大小写是有区分的，由于wps的关系，自动大写了，我也不太会用wps这些工作软件 4.运算符的顺序 运算公式中预算符的计算顺序，称为运算符的顺序，比如在日常生活数学老师和我们说，先乘除后加减，运算符的优先顺序我会在后文排序出表格。 5.运算符的结合 一个运算公式，运算符顺序相同时，按照一般的计算规律，有从左到右和从右到左两种顺序，以加减运算为例子，2+3-4 中先计算 2+3 ，之后用 2+3 的和减
去 4 ，5-4 ，有关规律请参照后文。 2.1 运算符 2.2 “=”运算符的解释 在学生时代，老师对我们说，“=”号是等于的作用，但是在程序当中，“=”号的功能会和老师所说的“等于”不同，所有，我们不能以“等于”这个观点去理解程序的“=”号。 请看如下代码: Int a,b,c; B=1; c=2; A=b+c; 以上代码的意思是如果使用“等于”观念来思考，可能觉得没什么差别，就是位置改变了。 请看如下代码： Int a; A=a+1; 当看了此段代码，你在用“等于”观念来思考，你会觉得，一切都觉得很奇怪。这时候你就应该用程序的观念去思考这段代码。 现在，我很大家说明程序的“=”号，在你宣告一个变量时，那个变量就是你系统存里面的一小部分，但是我们如何输入一些信息到变量呢 ? 这时候我们需要“=”号，例如 a=1; 就是把数字 1 放进了变量a里面，所以“=”号起的作用是赋值，例如小明给小红一支笔。因此，“等于”观念的“=”号和程序里的“=”号是不同的。 2.3 算数运算符 运算符号名称运算规律程序例子实例 + 加法从左到右 A + B 7 + 2 - 减法从
有些运算符在JAVA语言中存在着，但是在实际开发中我们或许很少用到它们，在面试题中却时常出现它们的身影，对于这些运算符的含义和用法，你是否还记得呢？ 自增（++）和自减（--）运算符 我们先来回答几个问题吧： Java代码 1.int i = 0; 2.int j = i++; 3.int k = --i; 这段代码运行后，i等于多少？j等于多少？k等于多少？太简单了？好，继续： Java代码 1.int i = 0; 2.int j = i++ + ++i; 3.int k = --i + i--; 代码执行后i、j、k分别等于多少呢？还是很简单？好，再继续： Java代码 1.int i=0; 2.System.out.println(i++); 这段代码运行后输出结果是什么？0？1？ Java代码 1.float f=0.1F; 2.f++; 3.double d=0.1D; 4.d++; 5.char c='a'; 6.c++; 上面这段代码可以编译通过吗？为什么？如果你能顺利回答到这里，说明你对自增和自减运算符的掌握已经很好了。 为了分析出上面提出的几个问题，我们首先来回顾一下相关知识：
?自增（++）：将变量的值加1，分前缀式（如++i）和后缀式（如i++）。 前缀式是先加1再使用；后缀式是先使用再加1。 ?自减（--）：将变量的值减1，分前缀式（如--i）和后缀式（如i--）。 前缀式是先减1再使用；后缀式是先使用再减1。 在第一个例子中，int j=i++;是后缀式，因此i的值先被赋予j，然后再自增1，所以这行代码运行后，i=1、j=0；而int k=--i;是前缀式，因此i先自减1，然后再将它的值赋予k，因此这行代码运行后，i=0、k=0。 在第二个例子中，对于int j=i++ + ++i;，首先运行i++，i的值0被用于加运算（+），之后i自增值变为1，然后运行++i，i先自增变为2，之后被用于加运算，最后将i两次的值相加的结果1+2=3赋给j，因此这行代码运行完毕后i=2、j=3；对于int k=--i + i--;用一样的思路分析，具体过程在此不再赘述，结果应该是i=0、k=2。 自增与自减运算符还遵循以下规律： 1.可以用于整数类型byte、short、int、long，浮点类型float、double， 以及字符串类型char。 2.在Java5.0及以上版本中，它们可以用于基本类型对应的包装器类Byte、 Short、Integer、Long、Float、Double、Character。 3.它们的运算结果的类型与被运算的变量的类型相同。 下面的这个例子验证以上列出的规律，它可以编译通过并执行。 Java代码 1.public class Test { 2. public static void main(String[] args) { 3. // 整型 4. byte b = 0; 5. b++; 6. // 整型 7. long l = 0; 8. l++; 9. // 浮点型 10. double d = 0.0; 11. d++; 12. // 字符串 13. char c = 'a'; 14. c++; 15. // 基本类型包装器类 16. Integer i = new Integer(0); 17. i++;
C语言运算符号的种类 1 算术运算符 用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减(--)共七种。 2.关系运算符 用于比较运算。包括大于(>)、小于(<)、等于(==)、大于等于(>=) 、小于等于(<=)和不等于(!=)六种。 3.逻辑运算符 用于逻辑运算。包括与(&&)、或(||)、非(!)三种。 4.位操作运算符 参与运算的量，按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。 5.赋值运算符 用于赋值运算，分为简单赋值(=)、复合算术赋值(+=,-=,*=,/=,%=)和复合位运算赋值(&=,|=,^=,>>=,<<=)三类共十一种。 6.条件运算符 这是一个三目运算符，用于条件求值(?:)。 7.逗号运算符 用于把若干表达式组合成一个表达式(，)。 8.指针运算符 用于取内容(*)和取地址(&)二种运算。 9.求字节数运算符 用于计算数据类型所占的字节数(sizeof)。
10.特殊运算符 有括号()，下标[]，成员(→，.)等几种。 C语言运算符号的优先级 结合方向左结合(自左至右) ( ) 圆括号 [ ] 下标运算符 -> 指向结构体成员运算符 . 结构体成员运算符(请注意它是一个实心圆点) 结合方向右结合(自右至左)单目运算符 ! 逻辑非运算符 ~ 按位取反运算符 ++ 自增运算符 -- 自减运算符 - 负号运算符 (类型) 类型转换运算符 * 指针运算符 & 地址与运算符 sizeof 长度运算符
结合方向左结合双目运算符* 乘法运算符 / 除法运算符 % 取余运算符 结合方向左结合双目运算符+ 加法运算符 - 减法运算符 结合方向左结合双目运算符<< 左移运算符 >> 右移运算符 结合方向左结合双目运算符<、<=、>、>= 关系运算符 结合方向左结合双目运算符== 等于运算符(判断) != 不等于运算符(判断)
C语言中的自加自减运算 C语言作为一种计算机程序设计语言，它既具有高级语言的特点，又具有汇编语言的特征，编程功能十分强大。C语言定义了丰富的运算，多达40余种，这给c语言的学习带来了一定的困难。++运算（自加运算）和--运算（自减运算）正是这些运算中极具特点而又非常重要的两种运算，在教学中，历来是教学的难点，而关于这方面的系统的讲解资料又很难找到，本人在c语言教学中，对++和--运算就教学中碰到的问题，做了一些探索性的研究，现归纳总结，以期与同行共勉。 一、运算的定义 1. ++（自加运算）的定义 ++（自加运算）是单目运算，且只能以变量为运算对象，如i++，++a等（i，a为已定义变量），它等效于i=i+1（a=a+1），但是，自加运算又有自己的特点――与其它运算的相关性，虽然对变量i来讲，i++与++i没有什么区别，但当i++和++i还参与其它运算时，i++和++i对整个运算结果的影响是不同的，例如有如下程序段： int i=1 ，s ； s=（i++）+1； printf（“i=%d；s=%d＼n”，i，s）； 其运行结果是：i=2；s=2
若将程序中s=（i++）+1；换为s=（++i）+1；其它不变，其运行结果就会变为：i=2；s=3 ，此处我们可以看到： i++与++i的不同，并不影响i本身的结果，但却对s的值产生了不同的影响，这是因为系统在处理++i时先对i进行了加1运算，即：i=i+1，然后才参与其它运算，而在执行i++时，现将i的值参与其它运算，然后才给自己加1，所以得到的s的值是不同的，这正是++（自加运算）与众不同的地方。 2. --（自减运算）的定义 与自加运算类似，--（自减运算）也是单目运算，且只能以变量为运算对象，若i为已定义变量，i的自减运算分为--i和i-- ，两者对i自身的作用是一样的，即i=i-1 ，但当它们还参与其它运算时，--i先执行自减1运算，然后以i的值参与其它运算，i--则先以i值参与其它运算，然后对i进行自减1运算。 二、经典题型 下列程序执行后输出结果是什么？ main（） {int a=100； printf（“a++=%d；”，a++）；*/①/* printf（“++a=%d；”，++a）；*/②/* printf（“a--=%d；”，a--）；*/③/* }
C语言自增自減问题总结 在程序设计中，经常遇到“i=i+1”和“i=i-1”这两种极为常用的操作。C 语言为这种操作提供了两个更为简洁的运算符，即++和--，分别叫做自增运算符和自减运算符。它们是单目运算符，是从右向左结合的算术运算符。学习和应用这两个运算符时应注意以下几点： 我将自增自减运算符和变量结合在一下的表达式称为自增自减表达式，如 x++，--I等。通常情况下就有以下的结论： 1‘’前缀表达式：++x, --x; 其中x表示变量名，先完成变量的自增自减1运算，再用x的值作为表达式的值；即“先变后用”，也就是变量的值先变，再用变量的值参与运算。 2、后缀表达式：x++, x--; 先用x的当前值作为表达式的值，再进行自增自减1运算。即“先用后变”，也就是先用变量的值参与运算，变量的值再进行自增自减变化，。 如a=8; b=a++; c=++a; 其中赋给变量b的值为表达式(a++)的值，不应该理解为a的值，则b=8, c=10； 3、自增、自减运算只能用于单个变量，只要是标准类型的变量，不管是整型、实型，还是字符型变量等，但不能用于表达式或常量。如：++(a+b), 与5++，const int N=0; N++; 等都是错误的。而i+++j++、++i+(++j)、++a+b++、++array ［--j］；等，这些都是合法的。 4、再说结合性与结合方向 编译器对程序编译时，从左到右尽可能多地将字符组合成一个运算符或标识符，因此i+++j++等效于(i++)+(j++)，两个“++”作用的对象都是变量，这是合法的；而++i+++j等效于++(i++)+j,第1个“++”作用的对象是表达式 “i++”，这是不允许的。 自增自减运算符是单目运算符，其结合性是从右到左。表达式k=-i++等效于k=(-i)++还是k=-(i++)?。因为负号也是单目运算符，因此，上式从右到左结合，等效于k=-(i++)；若i=5，则表达式k=-i++运算之后k的值为-5，i的值为6。此赋值表达式的值即为所赋的值-5。不要因为k=-i++等效于k=-(i++)
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
常用数学符号大全、关系代数符号 1、几何符号 ⊥∥∠⌒⊙≡≌△ 2、代数符号 ∝∧∨～∫≠≤≥≈∞∶ 3、运算符号 如加号（＋），减号（－），乘号（×或·），除号（÷或／），两个集合的并集（∪），交集（∩），根号（√），对数（log，lg，ln），比（：），微分（dx），积分（∫），曲线积分（∮）等。 4、集合符号 ∪∩∈ 5、特殊符号 ∑π（圆周率） 6、推理符号 |a| ⊥∽△∠∩∪≠≡±≥≤∈← ↑→↓↖↗↘↙∥∧∨ &; § ①②③④⑤⑥⑦⑧⑨⑩ ΓΔΘΛΞΟΠΣΦΧΨΩ αβγδεζηθικλμν ξοπρστυφχψω ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫ ⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹ
∈∏∑∕√∝∞∟∠∣∥∧∨∩∪∫∮ ∴∵∶∷∽≈≌≒≠≡≤≥≦≧≮≯⊕⊙⊥ ⊿⌒℃ 指数0123：o123 7、数量符号 如：i，2+i，a，x，自然对数底e，圆周率π。 8、关系符号 如“＝”是等号，“≈”是近似符号，“≠”是不等号，“＞”是大于符号，“＜”是小于符号，“≥”是大于或等于符号（也可写作“≮”），“≤”是小于或等于符号（也可写作“≯”），。“→”表示变量变化的趋势，“∽”是相似符号，“≌”是全等号，“∥”是平行符号，“⊥”是垂直符号，“∝”是成正比符号，（没有成反比符号，但可以用成正比符号配倒数当作成反比）“∈”是属于符号，“??”是“包含”符号等。 9、结合符号 如小括号“（）”中括号“［］”，大括号“｛｝”横线“—” 10、性质符号 如正号“＋”，负号“－”，绝对值符号“| |”正负号“±” 11、省略符号 如三角形（△），直角三角形（Rt△），正弦（sin），余弦（cos），x的函数（f(x)），极限（lim），角（∠）， ∵因为，（一个脚站着的，站不住） ∴所以，（两个脚站着的，能站住）总和（∑），连乘（∏），从n个元素中每次取出r个元素所有不同的组合数（C(r)(n) ），幂（A，Ac，Aq，x^n）等。
C语言自增自减运算符总结 978299005@https://www.doczj.com/doc/412999618.html, 【例】 int i=5, j=5, p, q; p = (i++) + (i++); q = (++j) + (++j); printf("%d, %d, %d, %d\n", i, j, p, q); i=5; j=5; p = (i++) + (i++) + (i++); q = (++j) + (++j) + (++j); printf("%d, %d, %d, %d\n", i, j, p, q); i=5; j=5; p = (i++) + (i++) + (i++) + (i++); q = (++j) + (++j) + (++j) + (++j); printf("%d, %d, %d, %d\n", i, j, p, q); i=5; j=5; p = (i++) + (i++) + (i++) + (i++) + (i++); q = (++j) + (++j) + (++j) + (++j) + (++j); printf("%d, %d, %d, %d\n", i, j, p, q); 【讲解】 在VC6.0下编译，运行。 这段程序的运行结果是 7, 7, 10, 14 8, 8, 15, 22 9, 9, 15, 22 10, 10, 25, 41 可见a++这类运算，是整个式子算完以后，统计一下有几个++，再统一给a加上几。而
++a这类运算，在2个以下的时候，是先统计下有几个++，然后都加上去，然后再进行赋值。超过两个了，那么第三个开始，就是分步来，前两个算完了，第三个把前面得到的值拿来用。所以，q = (++j) + (++j) + (++j); (j=5)q就等于7+7+8=22. 总结一句话：vc环境中： ++i++i先使i的值自增两次再赋值！ i++i++先赋值再使i的值自增两次！ 【注意】 自增自减运算符的对象是变量，不是常量或表达式。如+ + i + + +j就不合法。这是因为C 语言的编译器对程序编译时，从左到右尽可能多地将字符组成一个运算符或标识符，因此+ + i + + +j 等效于+ + ( i + + ) + j , 第1 个“ + + ”作用的对象是表达式“i + + ” 这是不允许的。 【汇编的依据】 原理表达式中除了预算法本身的优先级外，还有一个结合性问题。在++j + ++j + ++j;中，因为存在两个同级的＋运算，根据＋运算符的左结合性，在编译时，其实是先处理前面的（++j + ++j）这部分，然后再将此结果再和++j相加。具体过程参见汇编代码： int b = ++j + ++j + ++j; 0040B7DD mov ecx,dword ptr [ebp-8] 0040B7E0 add ecx,1 0040B7E3 mov dword ptr [ebp-8],ecx // 第一个++j 0040B7E6 mov edx,dword ptr [ebp-8] 0040B7E9 add edx,1 0040B7EC mov dword ptr [ebp-8],edx // 第二个++j 0040B7EF mov eax,dword ptr [ebp-8] 0040B7F2 add eax,dword ptr [ebp-8] // ++j + ++j 0040B7F5 mov ecx,dword ptr [ebp-8] 0040B7F8 add ecx,1 0040B7FB mov dword ptr [ebp-8],ecx // 第三个++j 0040B7FE add eax,dword ptr [ebp-8] // ++j + ++j + ++j 0040B801 mov dword ptr [ebp-10h],eax // 赋值给b
常用数学符号大全 来源：网络 2009-08-17 13:40:20 [标签：数学] 1 几何符号 ?ⅷⅶ????△ 2 代数符号 ⅴⅸⅹ～???? ?ⅵ? 3运算符号 ×÷ⅳ± 4集合符号 ??ⅰ 5特殊符号 ⅲπ（圆周率） 6推理符号
|a| ??△ⅶ? ???±??ⅰ? ???↖↗↘↙ⅷⅸⅹ &; § ??←↑→↓?? ↖↗ ΓΔΘΛΞΟ ΠΣΦΧΨΩ αβγδεδε ζηθικλ μνπξζηυ θχψω Ⅰ Ⅱ Ⅲ Ⅳ Ⅴ Ⅵ Ⅶ Ⅷ Ⅸ Ⅹ Ⅺ Ⅻ ⅰ ⅱ ⅲ ⅳ ⅴ ⅵ ⅶ ⅷ ⅸ ⅹ ⅰⅱⅲ?ⅳⅴⅵ? ⅶ?ⅷⅸⅹ????
????????????????⊕?? ??℃ 指数0123：o123 上述符号所表示的意义和读法（中英文参照） ＋ plus 加号；正号 － minus 减号；负号 ± plus or minus 正负号 × is multiplied by 乘号 ÷ is divided by 除号 ＝ is equal to 等于号 ? is not equal to 不等于号 ? is equivalent to 全等于号 ? is approximately equal to 约等于 ? is approximately equal to 约等于号
＜ is less than 小于号 ＞ is more than 大于号 ? is less than or equal to 小于或等于? is more than or equal to 大于或等于％ per cent 百分之… ⅵ infinity 无限大号 ⅳ (square) root 平方根 X squared X的平方 X cubed X的立方 ? since; because 因为 ? hence 所以 ⅶ angle 角 ? semicircle 半圆 ? circle 圆 ○ circumference 圆周
自增自减运算符 ++i应该理解为执行完全部++运算后，然后进行其他运算 i++应该理解为执行完整个表达式后再进行自增运算 #include
#include
C语言中自增自减运算符教学探究 0引言 C语言编程设计中，若合理使用自增自减运算符，则可以节省代码，提高效率；若不能正确理解和掌握，则容易造成错误，这往往让学生初学时甚是费解。教学中，有必要对其进行细致分析，让学生理解并掌握自增自减运算符的使用方法和技巧。 1自增自减运算符基本知识 C语言程序设计中提供了两个用于变量递增和递减的特殊运算符。使单个变量的值增加1的运算符称之为自增运算符，用“++”表示；使单个变量的值减少1的运算符称之为自减运算符，用“--”表示。自增自减运算符都是单目运算符，即只能对一个对象施加运算，运算结果仍赋予该对象，即结果保存在原变量的存储单元中。例如，int i=2； i++；执行i++后，i=3。此时，原变量i存储单元中存放的值变为3。这里i++等价于i=i+1，当然，i--就等价于i=i-1。 自增自减运算符的操作对象只能是变量，而不能是常量或表达式。只要其运算的对象是标准的变量，无论是整型、实型或是枚举型均可作为运算对象，而常量和表达式无存储单元可言，自然不能做自增自减运算。例如：++n、i--合法，而++10、（i+j）++非法。因为若是常量，常量的值无法改变，无法自加1；若是表达式，如（i+j）++，假如i+j=5，自增后的值为6无变量空间可供存放，所以是非法的表达式。 自增自减运算符包括两种情形：前置式（++i，--i）和后置式（i++，i--）。前置式和后置式的含义分别为：++i：变量i先自增1，然后再使用
该变量i的值；--i：变量i先自减1，然后再使用该变量i的值；i++：先使用变量i的值，然后变量i再自增1；i--：先使用变量i的值，然后变量i再自减1。即前置运算是“先变后用”，而后置运算是“先用后变”。当自增自减表达式作为单一语句出现时，二者没有区别，但把它们引用在表达式中则有明显区别。例如：{int i=9； x=i++； y=i；}的执行结果x=9，y=10，后置运算是“先用后变”。而{int i=9； x=++i； y=i；}的执行结果x=10，y=10，即前置运算是“先变后用”。因此，自增自减运算符放在变量的前面还是后面，其运算顺序不同，运算结果也不同。 自增自减运算符按照“自右至左”的结合性进行运算，操作数只有一个，属于单目运算符，优先级为2，高于其它双目运算符和三目运算符的优先级。例如： int main（） { int i=10，j； j=-i--； printf（“i=%d，j=%d”，i，j）； } 例子中j=-i--为表达式，程序执行j=（-i）--，还是执行j=-（i--）呢？这里自减运算符“--”和取反运算符“-”都为单目运算符，优先级均为2，结合方向都自右至左。C语言规定，相同优先级运算符的运算先后次序由结合方向来决定，而两个运算符都是右结合性，故表达式执行j=-（i--）操作，执行结果是：i=9，j=-10。 2自增自减运算符的应用 学生在学习自增自减运算符时，关键是要掌握前置运算符是“先变后
3自增、自减运算符运算规则的理解 3．1目前出现的问题 在目前大多数的教科书中。对于自增、自减运算符的运算规 则的描述通常比较简单。论述自增、自减运算符的结合方向是“从 右至左”，谈及自增、自减运算符的优先级的则是“高于算术运算” 【1】。笔者认为这种论述不够全面，会造成初学者片面的理解。例 如： main0 f 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=15 a=6，b=12 a=6，b=1 5 而实际上，程序运行以后，得到的结果是： a=6，b=18 a=6，b=9 a=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，即后缀形式运算的优先级低于算 术运算． 因此，关于自增、自减运算符的规则我们可以理解为，在赋值 语句中，自增、自减运算符若作为前缀形式，其运算优先级高于其 它算术运算，即先按照“从右至左”的结合性进行自增、