In the previous sections we talked about data types, functions, code Execution order, and some ways to add simple functions.
In this section we will focus on operators. Includes the meaning of operators and the concept of precedence
In the C language, the following operators are recognized:
A detailed explanation of C + + language operators
Priority level |
Operator |
Name and Meaning |
Operational accounts |
Using the example |
Combination direction |
Can overload |
Additional Instructions |
No |
() |
Round Brackets |
Monocular |
(expression) |
No |
Whether |
Expression in parentheses is always calculated first |
No |
dynamic_cast<> () |
Type dynamic Conversions |
Monocular |
dynamic_cast< target type > (source) |
No |
Whether |
C + + proprietary, cannot convert return null |
No |
static_cast<> () |
Type static conversions |
Monocular |
static_cast< target type > (source) |
No |
Whether |
C + + proprietary, no detection conversion "NOTE 1" |
No |
reinterpret_cast<> () |
Type Interpretation transformation |
Monocular |
reinterpret_cast< target type > (source) |
No |
Whether |
C + + proprietary, cast "Note 1" |
No |
const_cast<> () |
Go to constant conversion |
Monocular |
const_cast< target type > (source) |
No |
Whether |
C + + proprietary, you can turn constants to very much |
0 |
:: |
Scope resolution |
Binocular |
Domain Name:: Target Name |
From left to right |
Whether |
C + + Proprietary |
1 |
[] |
Subscript operator |
Binocular |
Array name [expression] |
From left to right |
Can |
Both languages have |
1 |
() |
Function call |
Binocular |
Function name (parameter) |
From left to right |
Can |
Both languages have |
1 |
. |
Object member Selection |
Binocular |
Object. Member |
From left to right |
Whether |
Both languages have |
1 |
- |
Pointer member selection |
Binocular |
Member, object pointer |
From left to right |
Whether |
Both languages have |
1 |
{} |
Combinatorial operations |
Unknown |
{statement 1; statement 2; .... statement N;} |
From left to right |
Whether |
Both languages have |
2 |
++ |
Self-increment operation |
Monocular |
Variable + + + + variable "NOTE 2" |
From left to right From right to left |
Can |
Both languages have |
2 |
-- |
Self-subtraction operations |
Monocular |
Variable-- --Variable "NOTE 2" |
From left to right From right to left |
Can |
Both languages have |
2 |
+ |
Positive sign |
Monocular |
+ Variable |
From right to left |
Can |
Both languages have |
2 |
- |
Minus sign |
Monocular |
-Variable |
From right to left |
Can |
Both languages have |
2 |
! |
Logical Non- |
Monocular |
! An expression |
From right to left |
Can |
Both languages have |
2 |
~ |
Bitwise REVERSE |
Monocular |
~ Variable |
From right to left |
Can |
Both languages have |
2 |
* |
Pointer dereference |
Monocular |
* pointer |
From right to left |
Can |
Both languages have |
2 |
& |
Fetch Address |
Monocular |
& Variables |
From right to left |
Can |
Both languages have |
2 |
Type |
Forcing type conversions |
Monocular |
(type) source |
From right to left |
Can |
Both languages have |
2 |
sizeof |
Get variable occupancy Space size Memory |
Monocular |
sizeof (source) |
From right to left |
Whether |
Both languages have |
2 |
New/new[] |
Allocating memory |
Monocular |
New type name or new[] type name |
From right to left |
Can |
C + + Proprietary |
2 |
Delete/delete[] |
Freeing memory |
Monocular |
Delete pointer or delete[] pointer |
From right to left |
Can |
C + + Proprietary |
3 |
.* |
Member Object Selection |
Binocular |
Object. * Member name or Object. * Member Pointers |
From left to right |
Can |
C + + Proprietary |
3 |
->* |
Member Pointer selection |
Binocular |
The object pointer->* the member name or Object pointer->.* member pointer |
From left to right |
Can |
C + + Proprietary |
4 |
* |
Multiplication |
Binocular |
Variable 1* variable 2 |
From left to right |
Can |
Both languages have |
4 |
/ |
Division |
Binocular |
Variable 1/Variable 2 |
From left to right |
Can |
Both languages have |
4 |
% |
Take surplus |
Binocular |
Variable 1% variable 2 |
From left to right |
Can |
Both languages have |
5 |
+ |
Addition |
Binocular |
Variable 1+ variable 2 |
From left to right |
Can |
Both languages have |
5 |
- |
Subtraction |
Binocular |
Variable 1-Variable 2 |
From left to right |
Can |
Both languages have |
6 |
<< |
Bitwise LEFT Shift |
Binocular |
Variable 1<< variable 2 |
From left to right |
Can |
Both languages have |
6 |
>> |
Bitwise RIGHT SHIFT |
Binocular |
Variable 1>> variable 2 |
From left to right |
Can |
Both languages have |
7 |
< |
Less than |
Binocular |
Variable 1< variable 2 |
From left to right |
Can |
Both languages have |
7 |
<= |
No greater than |
Binocular |
Variable 1<= variable 2 |
From left to right |
Can |
Both languages have |
7 |
> |
Greater than |
Binocular |
Variable 1> variable 2 |
From left to right |
Can |
Both languages have |
7 |
>= |
Not less than |
Binocular |
Variable 1>= variable 2 |
From left to right |
Can |
Both languages have |
8 |
== |
Logic, etc. |
Binocular |
Variable 1== variable 2 |
From left to right |
Can |
Both languages have |
8 |
!= |
Not equal to |
Binocular |
Variable 1! = Variable 2 |
From left to right |
Can |
Both languages have |
9 |
& |
and arithmetic |
Binocular |
Variable 1& variable 2 |
From left to right |
Can |
Both languages have |
10 |
^ |
XOR or operation |
Binocular |
Variable 1^ variable 2 |
From left to right |
Can |
Both languages have |
11 |
| |
or arithmetic |
Binocular |
Variable 1| variable 2 |
From left to right |
Can |
Both languages have |
12 |
&& |
Logic and |
Binocular |
Variable 1&& variable 2 |
From left to right |
Can |
Both languages have |
13 |
|| |
Logical OR |
Binocular |
Variable 1| | Variable 2 |
From left to right |
Can |
Both languages have |
14 |
?: |
Conditional operations |
Tri-Mesh |
Variable 1? Variable 2: Variable 3 |
From right to left |
Whether |
Both languages have |
15 |
= |
Assign value |
Binocular |
Variable 1 = variable 2 |
From right to left |
Can |
Both languages have |
15 |
+= |
Add after Assignment |
Binocular |
Variable 1+= variable 2 |
From right to left |
Can |
Both languages have |
15 |
-= |
Reduced-value Assignment |
Binocular |
Variable 1-= variable 2 |
From right to left |
Can |
Both languages have |
15 |
*= |
Multiply post-Assign value |
Binocular |
Variable 1*= variable 2 |
From right to left |
Can |
Both languages have |
15 |
/= |
Assign value after addition |
Binocular |
Variable 1/= variable 2 |
From right to left |
Can |
Both languages have |
15 |
%= |
Post-remainder assignment value |
Binocular |
Variable 1%= variable 2 |
From right to left |
Can |
Both languages have |
15 |
<<= |
Left Shift Assignment |
Binocular |
Variable 1 <<= variable 2 |
From right to left |
Can |
Both languages have |
15 |
>>= |
Shift Right Assignment |
Binocular |
Variable 1 >>= variable 2 |
From right to left |
Can |
Both languages have |
15 |
&= |
and post-assignment values |
Binocular |
Variable 1 &= variable 2 |
From right to left |
Can |
Both languages have |
15 |
^= |
XOR/Assign Value |
Binocular |
Variable 1 ^= variable 2 |
From right to left |
Can |
Both languages have |
15 |
|= |
or post-assignment value |
Binocular |
Variable 1 |= variable 2 |
From right to left |
Can |
Both languages have |
16 |
Throw |
Throw exception |
Monocular |
Throw Variable 1 |
From right to left |
Whether |
C + + Proprietary |
17 |
, |
Comma operation |
Binocular |
Variable 1, variable 2 |
From left to right |
Can |
Both languages have |
Note 1:reinterpret_cast<> () andstatic_cast<> () all seem to be casts, but the two are different
Observe the following code:
class A {
public:
A(){ m_a = 1; }
int m_a;
};
class B {
public:
B(){ m_b = 2; }
int m_b;
};
class C : public A, public B
{
};
void OperatorPriority()
{
C c;
printf("%p, %p, %p\n", &c, reinterpret_cast<B*>(&c), static_cast <B*>(&c));
B* b1 = &c, *b2 = reinterpret_cast<B*>(&c), *b3 = static_cast <B*>(&c);
printf("%d, %d, %d\n", b1->m_b, b2->m_b, b3->m_b);
}
After executing the operatorpriority () function, the output is as follows:
What does that mean?
This means that at the time of the conversionreinterpret_cast<> () is a no-brain conversion, completely regardless of the cause and the consequences, to cast
andstatic_cast<> () will try to match first, can match will make processing, otherwise cast
So M_bstatic_cast<> () will output the correct value, andreinterpret_cast<> () will give an error value
But why is forcing type conversion to output M_b correctly? This involves the polymorphic nature of C + +, which I'll talk about later. Only operators are discussed here, not in-depth explanations.
Note 2: Prefix increment/decrement operation and suffix increment/decrement operation
The prefix increment/decrement is such that the + + variable--variable
The suffix increment/decrement is such a variable + + variable--
There is a lot of information that suffix increment/decrement operations have precedence over prefixes
This is too simple to say, the actual situation is very complex (that is, this statement is completely a head, no practice of the nonsense!) )
First, look at the code:
From the above code can be clearly seen, if you think the suffix of the increment operation has so-called high priority, then completely does not make sense.
First of all, the statement is a grammatical error ++a--! The prefix and postfix operators cannot be performed at the same time, so they cannot be compared to their precedence.
However, this does not mean that the priority descriptions on the Web are wrong, because we can compare them with other operators of their peers.
Note the TEST002 Function! The operation is an operator of the same class as the prefix increment operation, which is supposed to be calculated by first calculating the suffix increment and then calculating the non,
This should be equivalent to a=! (a++) that the result should be 0. But why is the output 1?
The answer is complicated. The actual operation above is done as follows:
Calculate the calculation first a++ namely 0++=1 Save the result to a and then follow a=0 calculate!a namely!0=1, save result again to a result is a finally become 1
Here is the disassembly of the Code
a = !a++;
00113EBD 8B 45 F8 mov eax,dword ptr [a]
00113EC0 89 85 30 FF FF FF mov dword ptr [ebp-0D0h],eax
00113EC6 8B 4D F8 mov ecx,dword ptr [a]
00113EC9 83 C1 01 add ecx,1
00113ECC 89 4D F8 mov dword ptr [a],ecx
00113ECF 83 BD 30 FF FF FF 00 cmp dword ptr [ebp-0D0h],0
00113ED6 75 0C jne main+0B4h (0113EE4h)
00113ED8 C7 85 2C FF FF FF 01 00 00 00 mov dword ptr [ebp-0D4h],1
00113EE2 EB 0A jmp main+0BEh (0113EEEh)
00113EE4 C7 85 2C FF FF FF 00 00 00 00 mov dword ptr [ebp-0D4h],0
00113EEE 8B 95 2C FF FF FF mov edx,dword ptr [ebp-0D4h]
00113EF4 89 55 F8 mov dword ptr [a],edx
On the surface, suffix + + appears to be the preferred operation. But we can't just focus on this, but focus on its impact on the results.
The operation is not calculated first, it is high priority--if the operation is not able to affect the result
The result of the operation of this expression a++ is discarded, that is! The operator masks the suffix ++!!!
Does it feel a little messy? No matter, we look at other functions, so you will be more messy!
See function test003 test004
The calculation of 003 is carried out as follows: The first calculation A+a namely 0+0 obtains 0, then calculates the increment namely 0++ obtains 1. Last assignment, take the value of a++ 1
The following is the actual calculation process
00DD3E55 8B 45 F8 mov eax,dword ptr [a]
00DD3E58 03 45 F8 add eax,dword ptr [a]
00DD3E5B 89 45 F8 mov dword ptr [a],eax
00DD3E5E 8B 4D F8 mov ecx,dword ptr [a]
00DD3E61 83 C1 01 add ecx,1
00DD3E64 89 4D F8 mov dword ptr [a],ecx
In other words, the a+a is calculated first, and then the a++
This is not a description of the + operator priority higher than the suffix + +!!
The calculation of 004 is carried out as follows: First calculate 2+a namely 2+0 get 2, then calculate self-increment, namely 2++, get 3
01383E89 8B 45 F8 mov eax,dword ptr [a]
01383E8C 83 C0 02 add eax,2
01383E8F 89 45 F8 mov dword ptr [a],eax
01383E92 8B 4D F8 mov ecx,dword ptr [a]
01383E95 83 C1 01 add ecx,1
01383E98 89 4D F8 mov dword ptr [a],ecx
Get the same logical result + operator precedence higher than suffix + +
Now let's sum it up:
Postfix operator and! operator together, the suffix operator is masked
When the postfix operator and the +-*/operator are together, the other is computed, and the self-increment
Now, are you completely confused?
Good, that's right.
Because we now have a conclusion:
1 those so-called priorities are all nonsense, and don't expect priorities to be executed exactly as you expect them to.
2 Please arrange the priority with parentheses-only This is the only reliable partner!
At the beginning of the next section I will analyze and explain the operators one by one, so please look forward to ...
Zerglurker C-Language tutorial 009--operator details (i)