Prefix increment/decrement's Precedence is lower than Array subscripting

Question

3.56/5 (3 votes)

See more:

Prefix increment/decrement's Precedence is lower than Array subscripting?
I referenced it from here[^]

I'm puzzled, how to explain this expression?

C++

int buff[5] = { 10, 20, 30, 40, 50 };
int idx = 0;
int num = buff[++idx];
assert(num == buff[1]);

as the result shows, ++ excute first then []. but it conflict with the precedence table as I referenced.

anyone knows? thanks very much.

Posted 5-Jan-14 19:26pm

BCN-163

Add a Solution

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Aescleal · Accepted Answer · 2014-01-06T00:40:00

The precedence table is only consulted within an expression, it has no effect across expressions. Expressions are completely evaluated before their results are used.

An array de-reference is a composite expression. It consists of two component expressions, one outside the square brackets and one inside:

base_address_expression[ index_expression ]

index_expression is completely evaluated before it's used as part of the overall expression:

const auto t = index_expression;
base_address_expression[ t ]

This happens whatever index_expression is - a function call, another array dereference or another complex arithmetic expression. It get's calculated first, completely, then used.

Stefan_Lang · Accepted Answer · 2014-01-05T23:50:00

This is not a case of precedence, but of evaluating function arguments.operator[] is a function with one argument, and this argument must always be evaluated before passing it to the function. Since in this case the argument is an expression, the result of the expression is used as an argument. You could use the postfix increment instead if you wanted to pass 0, rather than 1.

The operator precedence rules would only be applied if you used the increment operator on buff like this:

C++

int num = ++buff[idx];

P.S. - an explanation of my first statement:
In C++ you can overload definitions for operators working on arguments of a specific class. This is called operator overloading. There are plenty of articles on this topic, e.g. here[^], but the one thing I was referring to is that when you overload the [] operator, the signature of the function must look like that of a function with one argument: the index value of the element you want to access.

That means whenever you invoke the [] operator, it is internally treated like a call to a function, and the first thing that is done then is that it's argument, the index value, is evaluated.

Prefix increment/decrement's Precedence is lower than Array subscripting

2 solutions

Solution 2

Solution 1

Add your solution here

Preview 0