summarize
This article provides an in-depth look at operator precedence as it relates to pointers and arrays, using code examples to show how to combine left and right union operators when both are present, as well as demonstrating how to use the()to force the binding order to be specified artificially.
Priority of pointers, array-related operators
The following table shows the priority of the relevant operators, there are 4 classes and operators within the same class are called in order of binding. These 4 classes are also the 4 highest priority classes of all operators, all other operators have lower priority than them:
| prioritization | operator (computing) | descriptive | associative (xy)z = x(yz) (math.) |
|---|---|---|---|
| 1 | :: | Scope resolution | left-hand side of the equation |
| 2 | () [] . -> |
Combining forced operations, function formal parameter lists Array element subscript access Class member access Member access to class pointers |
right-hand side (of a triangle) |
| 3 | (int) * & |
forced conversion pointer dereference variable fetch address |
left-hand side of the equation |
| 4 | .* ->* |
Pointer to a member of a class Member pointers to class pointers |
left-hand side of the equation |
What tends to be confusing and requires careful prioritization is often theA left union plus a right union, for example:
*ptr[](int)a()&class->dataobj->*fun()
Remember one.Key methods: When we need to change the order in which operators are combined (C++'s default priority is not what we want), we can do so by adding the()to artificially enforce priority, since()is the highest priority class of operators other than ::.
Simple Example: Exploring the Laws of Operator Combination Using [] and * as an Example
The following p1, p2 are arrays and p3 is a pointer:
int *p1[2]; // p1 is an array with 2 elements, each element is (int*)
int *(p2[2]); // Equivalent to *p2[2], p2 is an array
int (*p3)[2]; // p3 is a pointer to an int array that must have a number of elements of 2!
So just remember two things:
- **[] has a higher priority than * **: i.e.
*p1[2]respond in singing*(p1[2])Equivalent. - This prioritization also applies toDefinition statement (* is a pointer definer)cap (a poem)Execution statement (* is an unquote character)Center:
int *p1[2]; // Definition statement: first look at []:p1 is an array with 2 elements, each element is (int*). Equivalent to *(p1[2])
int (*p2)[2]; // Definition statement: first look at *: p2 is a pointer to an array of ints, which must have 2 elements!
cout << "*p1[0] = " << *p1[0] << endl; // Execution statement: look at [] first: take the 0th element first, then dereference it. Equivalent to *(p1[0])
cout << "(*p2)[0] = " << (*p2)[0] << endl; // Execute statement: look at * first: dereference first, then take the 0th element
Full Example:
#include <iostream>
using namespace std;
int main(){
// [] has higher precedence than *, so p1 below is an array and p2 is a pointer:
int *p1[2]; // p1 is an array with 2 elements, each element is (int*). Equivalent to *(p1[2])
int (*p2)[2]; // p2 is a pointer to an int array that must have 2 elements!
int a = 1, b = 2; // int p2 is a pointer to an int array that must have a number of elements of 2!
int c[2] = {4,5};
p1[0] = &a.
p1[1] = &b.
p2 = &c.
cout << "*p1[0] = " << *p1[0] << endl;
cout << "*p1[1] = " << *p1[1] << endl;
cout << "*(p1[0]) = " << *(p1[0]) << endl; // Equivalent to the above two articles
cout << "*(p1[1]) = " << *(p1[1]) << endl;
cout << "(*p2)[0] = " << (*p2)[0] << endl;
cout << "(*p2)[1] = " << (*p2)[1] << endl;
return 0;
}
Output:
*p1[0] = 1
*p1[1] = 2
*(p1[0]) = 1
*(p1[1]) = 2
(*p2)[0] = 4
(*p2)[1] = 5
Complex example: exploring how priority is defined when both left- and right-conjunction operators are present at the same time
The following example is a bit more complicated and requires patience to read and experience it carefully. If this example can be figured out, then I believe your understanding of operator precedence will go up a notch.
This example examines the order of binding when both the left and right binding operators are present, and also demonstrates that it's possible to use the()Compulsory artificial designation of the order of bonding:
#include <iostream>;
#include <string>
using namespace std.
class Student{
public.
Student(string name, int id):_name(name),_id(id){}
void printInfo(){
cout << "I am a student. My name is " << _name << ". My id is " << _id << endl;
}
void operator()(){
printInfo();
}
protected.
string _name; int _id; }
int _id; }
}; }
class Student2 : public Student{
public.
Student2(string name, int id):Student(name, id){}
void printInfo(){
cout << "I am a super Student!!!! " << endl;
}
void operator()(){
cout << "I am Student2!!!" << endl;
}
};
struct StudentWrapper{
Student* _ps.
StudentWrapper(Student* ps):_ps(ps){}
Student* operator()(){return _ps;}
};
int main(){
// . and (), -> and () level: left to right
cout << "-----------------1------------------" << endl;
Student s1("Bob", 101), s2("Jack", 102);
Student *ps1 = new Student("Eric",103);
();
();
ps1->printInfo();
// . Above *: first combine .
cout << "-----------------2------------------" << endl;
// The following statement reports an error: call .printInfo() first, then *, so it reports an error
// *(); // error: request for member 'printInfo' in 'ps1'
(*ps1).printInfo();
// . and () over *: first combine () and . (from right to left), and finally combining *
cout << "-----------------3------------------" << endl;
StudentWrapper sw(ps1);
// The following statement reports an error: it combines sw(), then .printInfo(), and finally *, so it reports an error
// *sw().printInfo(); // error: request for member 'printInfo' in '::operator()()'
(*sw()).printInfo(); // correct: sw(), then *sw(), then (*sw()).printInfo()
// The following statement reports an error: it combines sw(), then (), and finally *, and therefore reports an error
// *sw()(); // error: expression cannot be used as a function
(*sw())(); // correct: first sw(), then *sw(), then (*sw())()
// (int) and ()/[]: combine () and [] first, then strong transfer
cout << "-----------------4------------------" << endl;
Student2 ss("Alice", 999), sss("Jason", 998), ssArray[2] = {ss, sss};
ss(); // call Student2::operator()
// The following statement reports an error because it combines ss() before forcing a conversion
// (Student)ss(); // error: invalid use of void expression
((Student)ss)(); // correct: call Student::operator()
// The following statement throws an error because it combines ssArray[0], then ssArray[0](), and then forces the conversion.
// (Student)ssArray[0](); // error: invalid use of void expression
((Student)ssArray[1])(); // correct: call the () method after forcing the conversion of ssArray[1] to a Student type
// () is higher than . * and ->*: combining () first
cout << "-----------------5------------------" << endl;
void (Student::*fp)().
fp = Student::printInfo;
// s1.*fp(); // error: must use '. *' or '->*' to call pointer-to-member function in 'fp (...)'
(s1.*fp)(); (s2.*fp)().
(s2.*fp)(); // ps1-> ps1->.
// ps1->*fp(); // error: must use '. *' or '->*' to call pointer-to-member function in 'fp (...)'
(ps1->*fp)().
// (int) is higher than . * and ->*: combine (int) first
cout << "-----------------6------------------" << endl;
Student2 *ssp = &sss; // Jason
void (Student2::*fp2)().
fp2 = Student2::printInfo;
(ss.*fp2)().
((Student)ss.*fp)(); // Strongly convert ss to Student first, then call Student::printInfo(), noting that it's . *fp instead of . *fp2
((Student*)ssp->*fp)(); // Strongly convert ssp to Student* first, then call Student::printInfo(), noting that it's . *fp instead of . *fp2
// * is higher than . * and ->*: first combine *
cout << "-----------------7------------------" << endl;
(*ssp.*fp2)(); // *ssp first, then . *fp2
Student2 **sspp = &ssp.
(*sspp->*fp2)(); // first *sspp, then ->fp2
delete ps1; // first *sspp, then ->fp2
return 0;
}
Output:
-----------------1------------------
I am a student. My name is Bob. My id is 101
I am a student. My name is Jack. My id is 102
I am a student. My name is Eric. My id is 103
-----------------2------------------
I am a student. My name is Eric. My id is 103
-----------------3------------------
I am a student. My name is Eric. My id is 103
I am a student. My name is Eric. My id is 103
-----------------4------------------
I am Student2!!!
I am a student. My name is Alice. My id is 999
I am a student. My name is Jason. My id is 998
-----------------5------------------
I am a student. My name is Bob. My id is 101
I am a student. My name is Jack. My id is 102
I am a student. My name is Eric. My id is 103
-----------------6------------------
I am a super Student!!!
I am a student. My name is Alice. My id is 999
I am a student. My name is Jason. My id is 998
-----------------7------------------
I am a super Student!!!
I am a super Student!!!