C++运算符优先级

来源：百度文库 编辑：神马文学网 时间：2024/05/23 20:28:10

C++ Operator Precedence

The operators at the top of this list are evaluated first. Operators within a group have the same precedence. All operators have left-to-right associativity unless otherwise noted.
这张表格的头部的运算符是以数字形式表示的。处在一组的运算符有着相同的级别。除了有标记的外(right to left)，所有的运算符具有从左到右的结合律。

Precedence Operator Description Example Overloadable Associativity 1 :: Scope resolution operator Class::age = 2; no left to right 2 ()
()
[]
->
.
++
--
dynamic_cast
static_cast
reinterpret_cast
const_cast
typeid Function call
Member initalization
Array access
Member access from a pointer
Member access from an object
Post-increment
Post-decrement
Runtime-checked type conversion
Unchecked type conversion
Reinterpreting type conversion
Cast away/Add constness
Get type information isdigit('1')
c_tor(int x, int y) : _x(x), _y(y * 10) {}
array[4] = 2;
ptr->age = 34;
obj.age = 34;
for (int i = 0; i < 10; i++) cout << i;
for (int i = 10; i > 0; i--) cout << i;
Y& y = dynamic_cast(x);
Y& y = static_cast(x);
int const* p = reinterpret_cast(0x1234);
int* q = const_cast(p);
std::type_info const& t = typeid(x); yes
yes
yes
yes
no
yes
yes
no
no
no
no
no left to right 3 !
not
~
compl
++
--
-
+
*
&
sizeof
new
new []
delete
delete []
(type) Logical negation
Alternate spelling for !
Bitwise complement
Alternate spelling for ~
Pre-increment
Pre-decrement
Unary minus
Unary plus
Dereference
Address of
Size (of the type) of the operand in bytes
Dynamic memory allocation
Dynamic memory allocation of array
Deallocating the memory
Deallocating the memory of array
Cast to a given type if (!done) …

flags = ~flags;

for (i = 0; i < 10; ++i) cout << i;
for (i = 10; i > 0; --i) cout << i;
int i = -1;
int i = +1;
int data = *intPtr;
int *intPtr = &data;
size_t s = sizeof(int);
long* pVar = new long;
long* array = new long[20];
delete pVar;
delete [] array;
int i = (int)floatNum; yes

yes

yes
yes
yes
yes
yes
yes
no
yes
yes
yes
yes
yes right to left 4 ->*
.* Member pointer selector
Member object selector ptr->*var = 24;
obj.*var = 24; yes
no left to right 5 *
/
% Multiplication
Division
Modulus int i = 2 * 4;
float f = 10.0 / 3.0;
int rem = 4 % 3; yes
yes
yes left to right 6 +
- Addition
Subtraction int i = 2 + 3;
int i = 5 - 1; yes
yes left to right 7 <<
>> Bitwise shift left
Bitwise shift right int flags = 33 << 1;
int flags = 33 >> 1; yes
yes left to right 8 <
<=
>
>= Comparison less-than
Comparison less-than-or-equal-to
Comparison greater-than
Comparison greater-than-or-equal-to if (i < 42) …
if (i <= 42) ...
if (i > 42) …
if (i >= 42) ... yes
yes
yes
yes left to right 9 ==
eq
!=
not_eq Comparison equal-to
Alternate spelling for ==
Comparison not-equal-to
Alternate spelling for != if (i == 42) ...

if (i != 42) …
yes
-
yes
left to right 10 &
bitand Bitwise AND
Alternate spelling for & flags = flags & 42;
yes
left to right 11 ^
xor Bitwise exclusive OR (XOR)
Alternate spelling for ^ flags = flags ^ 42;
yes
left to right 12 |
bitor Bitwise inclusive (normal) OR
Alternate spelling for | flags = flags | 42;
yes
left to right 13 &&
and Logical AND
Alternate spelling for && if (conditionA && conditionB) …
yes
left to right 14 ||
or Logical OR
Alternate spelling for || if (conditionA || conditionB) ...
yes
left to right 15 : Ternary conditional (if-then-else) int i = a > b ? a : b; no right to left 16 =
+=
-=
*=
/=
%=
&=
and_eq
^=
xor_eq
|=
or_eq
<<=
>>= Assignment operator
Increment and assign
Decrement and assign
Multiply and assign
Divide and assign
Modulo and assign
Bitwise AND and assign
Alternate spelling for &=
Bitwise exclusive or (XOR) and assign
Alternate spelling for ^=
Bitwise normal OR and assign
Alternate spelling for |=
Bitwise shift left and assign
Bitwise shift right and assign int a = b;
a += 3;
b -= 4;
a *= 5;
a /= 2;
a %= 3;
flags &= new_flags;

flags ^= new_flags;

flags |= new_flags;

flags <<= 2;
flags >>= 2; yes
yes
yes
yes
yes
yes
yes

yes

yes

yes
yes right to left 17 throw throw exception throw EClass(“Message”); no   18 , Sequential evaluation operator for (i = 0, j = 0; i < 10; i++, j++) … yes left to right
 

Order of Evaluation and of Side Effects

One important aspect of C++ that is related to operator precedence, is the order of evaluation and the order of side effects in expressions. In most circumstances, the order in which things happen is not specified. For example in f() + g() whether f() or g() is called first is not specified. If at least one of the functions has side effects the results may differ across compilers, different versions of the same compiler or even between multiple runs of the same compiler.
C++有关运算符优先级的一个重要方面是在表达式中的赋值和副作用（与外界进行了交互，某些值可能发生了改变）的顺序。多数情况下，事件发生的顺序是不明确的。例如，在式子f()+g()中，是先调用f()还是先调用g()是不明确的。如果至少有一个函数有副作用，算得的结果可能因不同的编译器、一个编译器的不同版本甚至在同一个编译器上的多次运行而有所不同Further, the effect of certain expressions is undefined. For example, consider the following code:
进一步讲，某些表达式的效果是未定义的。例如，考虑下面的代码：
    float x = 1;x = x / ++x;

The value of x and the rest of the behaviour of the program after evaluating this expression is undefined. The program is semantically ill-formed: x is modified twice between two consecutive sequence points.

Expressions like the one above must be avoided. When in doubt, break a large expression into multiple statements to ensure that the order of evaluation is correct. x的值以及程序给表达式赋值后的后面的行为是不得而知的。这个程序从语义上讲是不规范的：在两个连续的序列点之间，x被修改了两次。像上面一样的表达式应该避免。当有歧义时，将一个复杂的表达式分解成多个陈述以保证赋值的顺序是正确的。 

Overloading of Operators

Overloading of operators can be very useful and very dangerous. On one hand overloading operators for a class you have created can help with logistics and readability of code. On the other hand you can overload an operator in such a way that it can either obfuscate or just downright break your program. Use carefully. In particular never overload &&, || or ,. In the overloaded context they lose the guarantee that the left operand is evaluated before the second and that there is a sequence point inbetween.
重载运算符可能非常有用，但也有危险。一方面为一个类重载运算符增加了代码的物流和可读性。另一方面可以在使人糊涂的地方或者完全使人迷惑的地方程序重载一个运算符。小心的重载，尤其是不要重载&&,||和,运算符。因为在重载的上下文中，他们失去了左操作数的赋值在第二个之前的保证，而且之间也会有顺序点。

There are two ways to over load an operator: global function or class member.

Example of overloading with a global function:
有两种方式来重载一个运算符：全局函数和类函数。重载全局函数的例子如下：
     ostream& operator <<(ostream& os, const myClass& rhs);
But to be able to reach any private data within a user defined class you have to declare the global function as a friend within the definition of the class.
为了访问一个用户定义的类里的私有数据，你必须声明全局函数为友元函数，并且在类中定义。

Example: 

     class myClass 
     {// Gives the operator << function access to 'myData'// (this declaration should not go in public, private or protected)friend ostream& operator <<(ostream& lhs, const myClass& rhs); private:int myData;}

Overloading with a class member can be done as follows: 

     class myClass 
     {public:// The left hand side of this operator becomes '*this'.int operator +(const myClass& rhs); private:int myData;}
C 运算符优先级列表 C、C++运算符优先级列表 C 语言运算符优先级等级口诀 C 运算符优先级列表 - brent‘s hut - C 博客 C++运算符优先级 C语言运算符及其优先级汇总表口诀 Java运算符和优先级 位操作运算符优先级 C语言运算符优先级 - C语言学习 - 开源共享与您共同分享 c 操作符 优先级 运算符优先级问题和宏 c++运算优先级列表 C++ 运算符优先级列表 - brent's hut - C++博客 C++ 运算符优先级列表 - brent's hut - C++博客 c语言运算符 c++运算优先级列表121 收藏： C 运算符重载 转换函数 - flyingfish - 博客园 C中所有运算符的优先级别记忆 C/C 开源技术网论坛 公式中的运算符 运算符 的 重载 VBScript 运算符 PHP 运算符 (Operators) SQL AND & OR 运算符 Delphi 的运算符列表