运营商

一旦引入变量和常量，我们可以开始使用他们来操作 运营。下面是运营商的一个完整列表。在这一点上，很可能没有必要知道所有这些，但它们都在此列出以兼作参考。

赋值运算符（=）

赋值运算符赋值给变量。

x = 5;

该语句将整数值 5给变量 x。赋值操作总是发生从右到左，从不周围的其他方式：

x = y;

该语句将变量 x包含在变量中的值 y。的值 x被执行的时刻此声明将丢失和的值替代 y。

考虑也是我们仅分配的值 y，以 x在分配操作的时刻。因此，如果 y在以后的时刻的变化，也不会影响所采取的新的值 x。

例如，让我们来看看下面的代码-我已经包括存储在变量作为评论内容的演变：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// assignment operator #include <iostream> using namespace std; int main () { int a, b; // a:?, b:? a = 10; // a:10, b:? b = 4; // a:10, b:4 a = b; // a:4, b:4 b = 7; // a:4, b:7 cout << "a:"; cout << a; cout << " b:"; cout << b; }

答：4 B：7

编辑及运行

这个程序打印在屏幕上的最终值的 a和 b（4和7，分别）。请注意如何 a在不影响最后的修改 b，尽管我们宣布 a = b较早。

分配操作是可以计算的表达式。这意味着，分配本身具有价值，和-用于类型-该值基本是一个在操作指定。例如：

y = 2 + (x = 5);

在这个表达式中， y被分配加入2的结果和另一赋值表达式的值（其具有自身的值为5）。它是大致相当于：

1 2

x = 5; y = 2 + x;

与分配7的最终结果 y。

下面的表达式也是C ++有效：

x = y = z = 5;

它分配5到所有三个变量： x， y和 z; 总是从右到左。

算术运算符（+， - ，*，/，％）

由C ++支持的五个算术操作是： 

操作者	描述
+	加成
-	减法
*	乘法
/	师
%	模

加法，减法，乘法和除法的操作字面上对应各自的数学运算。最后一个， 模运算符，按百分比符号（表示 %），给出了两个值的除法的余数。例如：

x = 11 % 3;

结果变量 x包含值2，因为11除以3的结果3，用2其余部分。

复合赋值（+ =， - =，* =，/ =％=，= >>，<< =，＆=，^ =，| =）

化合物赋值运算符通过在其上执行操作修改变量的当前值。它们等同于指定给第一操作数的运算的结果：

表达	相当于...
y += x;	y = y + x;
x -= 5;	x = x - 5;
x /= y;	x = x / y;
price *= units + 1;	price = price * (units+1);

与同为其他复合赋值运算符。例如：

1 2 3 4 5 6 7 8 9 10 11

// compound assignment operators #include <iostream> using namespace std; int main () { int a, b=3; a = b; a+=2; // equivalent to a=a+2 cout << a; }

五

编辑及运行

递增和递减（++， - ）

一些表达可以更加缩短：增加操作符（ ++）和减少操作者（ --）增加或减少一个存储在一个变量的值。它们是等效 +=1和 -=1分别。从而：

1 2 3

++x; x+=1; x=x+1;

在其功能相当于所有; 他们三人一个价值增加 x。

在早期的C编译器，前三个表达式可能会产生因使用哪一个不同的可执行代码。如今，这种类型的代码优化一般由编译器自动执行的，因而三个表达式应完全产生同样的可执行代码。

这个操作者的特点是，它可以既作为前缀和作为后缀使用。这意味着，它可以被写入任一变量名之前（ ++x）或之后（ x++）。虽然喜欢简单的表达 x++或者 ++x，两者有相同的含义; 在将递增或递减操作的结果被评估其他表达式，它们可以具有在它们的意义的一个重要区别：即增加操作者被用作前缀（在这种情况下 ++x的值的），则表达式的计算结果为最后的的值 x，一旦它已经被增大。另一方面，在情况下，它被用作后缀（ x++），该值也增加，但表达的计算结果为是X的增大之前的值。注意区别：

例1	例2
x = 3; y = ++x; // x contains 4, y contains 4	x = 3; y = x++; // x contains 4, y contains 3

在 实施例1中，分配给该值 y是的值 x被增加后。而在 实施例2，它是该值 x的增大前了。

关系和比较操作符（==，！=，>，<，> =，<=）

两个表达式可以使用关系和平等的运营商进行比较。例如，要知道，如果两个值相等，或者如果一个比另一个大。

这种操作的结果是真或假（即一个布尔值）。

在C ++中的关系运算符：

操作者	描述
==	等于
!=	不如
<	少于
>	比...更棒
<=	小于或等于
>=	大于或等于

这里有一些例子：

1 2 3 4 5

(7 == 5) // evaluates to false (5 > 4) // evaluates to true (3 != 2) // evaluates to true (6 >= 6) // evaluates to true (5 < 5) // evaluates to false

当然，这不只是数字常量可以比较的，只是任何价值，包括，当然，变数。假设 a=2， b=3和 c=6，则：

1 2 3 4

(a == 5) // evaluates to false, since a is not equal to 5 (a*b >= c) // evaluates to true, since (2*3 >= 6) is true (b+4 > a*c) // evaluates to false, since (3+4 > 2*6) is false ((b=2) == a) // evaluates to true

小心！赋值运算（操作员 =，与一个等号）是不一样的相等比较运算符（操作员 ==，具有两个等号）; 第一个（ =）分配在右手在其左侧的变量的值，而其它（ ==）进行比较运算符两侧的值是否相等。因此，在最后一个表达式（ (b=2) == a），我们首先分配值 2给 b，然后，我们比较它 a（即还存储值2），得到 true。

逻辑运算符（！，&&，||）

运营商 !是C ++运算符不布尔运算。它只有一个操作数，它的权利，并反转了，产生 false，如果其操作数是 true，而 true如果它的操作数 false。基本上，它返回评估其操作数的相对布尔值。例如：

1 2 3 4

!(5 == 5) // evaluates to false because the expression at its right (5 == 5) is true !(6 <= 4) // evaluates to true because (6 <= 4) would be false !true // evaluates to false !false // evaluates to true

逻辑运算符 &&和 ||正在评估两个表达式时用于获得单个关系的结果。操作者 &&对应于布尔逻辑运算AND，其产生 true如果其两个操作数都 true和 false其他。下面的面板显示操作符的结果 &&计算表达式 a&&b：

&&运算符（和）
a	b	a && b
true	true	true
true	false	false
false	true	false
false	false	false

操作 ||对应于布尔逻辑运算OR，这将产生 true如果任其操作数为 true，因此是假的，只有当两个操作数都是假的。以下是可能的结果 a||b：

|| 运营商（或）
a	b	a || b
true	true	true
true	false	true
false	true	true
false	false	false

例如：

1 2

( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false ) ( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false )

当使用逻辑运算符，C ++只评估什么是必要从左至右拿出合并关系的结果，忽视了休息。因此，在最后一个例子（ (5==5)||(3>6)），C ++计算第一是否 5==5是 true，如果是这样，它决不会检查是否 3>6是 true与否。这被称为 短路评价，和工作原理是这样，这些操作符：

操作者	短路
&&	如果左侧的表达是false，组合的结果是false（右手侧表达不会求）。
||	如果左侧的表达是true，组合的结果是true（右手侧表达不会求）。

这主要是重要的，当右手的表达有副作用，如改变价值观：

if ( (i<10) && (++i<n) ) { /*...*/ } // note that the condition increments i

这里，将合并的条件表达式将增加 i由一个，但只有当在左边的条件 &&就是 true，因为否则，在右手侧的条件（ ++i<n）是从来没有进行评价。

有条件的三元运算符（？）

条件运算符计算表达式，返回如果表达式计算为一个值 true，如果表达式的计算结果为一个不同的 false。它的语法是：

condition ? result1 : result2 

如果 condition是 true，则整个表达式的计算结果为 result1，否则到 result2。

1 2 3 4

7==5 ? 4 : 3 // evaluates to 3, since 7 is not equal to 5. 7==5+2 ? 4 : 3 // evaluates to 4, since 7 is equal to 5+2. 5>3 ? a : b // evaluates to the value of a, since 5 is greater than 3. a>b ? a : b // evaluates to whichever is greater, a or b.

例如：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// conditional operator #include <iostream> using namespace std; int main () { int a,b,c; a=2; b=7; c = (a>b) ? a : b; cout << c << '\n'; }

7

编辑及运行

在本例中， a为2，并且 b是7，所以表达式被评估（ a>b）不是 true，因此，问号之后指定的第一值有利于这是第二值（一个冒号后）的被丢弃 b（用7值）。

逗号（，）

逗号（ ,）被用于分离所包含在仅一个表达预计两个或更多个表达式。当表达式集具有的值来评估，只有最右边的表达被考虑。

例如，下列代码：

a = (b=3, b+2);

首先分配值3  b，然后分配 b+2给变量 a。所以，到了最后，变量 a将包含值5而变量 b将包含值3。

位运算符（＆，|，^，〜，<< >>）

位运算符修改考虑到代表它们存储的值的位模式的变量。

操作者	ASM相当于	描述
&	AND	按位与
|	OR	按位或
^	XOR	按位异或
~	NOT	一元补码（位反转）
<<	SHL	移位向左
>>	SHR	移位位权

显式类型转换操作符

类型转换操作符允许给定类型的值转换为另一种类型。有几种方法在C ++中做到这一点。最简单的一种，它已被从C语言继承，是先于表达由新型括号之间的封闭（（））被转换：

1 2 3

int i; float f = 3.14; i = (int) f;

上面的代码转换浮点数 3.14为整数值（ 3）; 的其余部分被丢失。在这里，类型转换经营者 (int)。另一种方式做同样的事情在C ++中是使用函数符号表达的前通过类型转换和圆括号之间的表达式：

i = int (f);

铸造类型的两种方式在C ++有效。

的sizeof

这个操作者接受一个参数，其可以是一个类型或一个变量，并且在该类型或对象的字节返回大小：

x = sizeof (char);

这里， x被分配的值 1，因为 char是用大小为一字节的类型。

返回的值 sizeof是一个编译时间常数，因此它总是在程序执行之前确定。

其他运营商

后来在这些教程中，我们会看到一些更多的运营商，像那些访问指向或面向对象编程的具体细节。

运算符的优先

一个表达式可以有多个运营商。例如：

x = 5 + 7 % 2;

在C ++中，上述表达式始终分配6变量 x，因为 %运营商比一个更高的优先级 +运营商，之前总是被判断。表达式的部分可以括号中覆盖此优先顺序，或作出明确清晰的预期效果。注意区别：

1 2

x = 5 + (7 % 2); // x = 6 (same as without parenthesis) x = (5 + 7) % 2; // x = 0

从最大到最小的优先级，C ++运算符按以下顺序计算：

水平	优先级组	操作者	描述	分组
1	范围	::	作用域限定符	左到右
2	后缀（一元）	++ --	后缀递增/递减	左到右
		()	函数形式
		[]	标
		. ->	成员访问
3	前缀（一元）	++ --	前缀递增/递减	右到左
		~ !	按位NOT /逻辑NOT
		+ -	一元前缀
		& *	参考/解除引用
		new delete	分配/释放
		sizeof	参数包
		(type)	C风格的类型转换
4	指针到成员	.* ->*	存取指针	左到右
五	算术：缩放	* / %	乘法，除法，模	左到右
6	算术：加	+ -	加法，减法	左到右
7	按位转移	<< >>	左移，右移	左到右
8	相关的	< > <= >=	比较运算符	左到右
9	平等	== !=	平等/不平等	左到右
10	和	&	按位与	左到右
11	异或	^	按位异或	左到右
12	包容或	|	位或	左到右
13	连词	&&	逻辑与	左到右
14	析取	||	逻辑或	左到右
15	赋值表达式级	= *= /= %= += -= >>= <<= &= ^= |=	分配/复合赋值	右到左
		?:	条件运算符
16	测序	,	逗号分隔符	左到右

当一个表达式有两家运营商具有相同优先级的水平， 分组确定哪一个先求：要么从左或从右到左。

括在括号中的所有子语句（即使是那些因为他们的优先不必要的）提高代码的可读性。