assignment operator priority

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• Português (do Brasil)

Operator precedence

Operator precedence determines how operators are parsed concerning each other. Operators with higher precedence become the operands of operators with lower precedence.

Precedence and associativity

Consider an expression describable by the representation below, where both OP1 and OP2 are fill-in-the-blanks for OPerators.

The combination above has two possible interpretations:

Which one the language decides to adopt depends on the identity of OP1 and OP2 .

If OP1 and OP2 have different precedence levels (see the table below), the operator with the higher precedence goes first and associativity does not matter. Observe how multiplication has higher precedence than addition and executed first, even though addition is written first in the code.

Within operators of the same precedence, the language groups them by associativity . Left-associativity (left-to-right) means that it is interpreted as (a OP1 b) OP2 c , while right-associativity (right-to-left) means it is interpreted as a OP1 (b OP2 c) . Assignment operators are right-associative, so you can write:

with the expected result that a and b get the value 5. This is because the assignment operator returns the value that is assigned. First, b is set to 5. Then the a is also set to 5 — the return value of b = 5 , a.k.a. right operand of the assignment.

As another example, the unique exponentiation operator has right-associativity, whereas other arithmetic operators have left-associativity.

Operators are first grouped by precedence, and then, for adjacent operators that have the same precedence, by associativity. So, when mixing division and exponentiation, the exponentiation always comes before the division. For example, 2 ** 3 / 3 ** 2 results in 0.8888888888888888 because it is the same as (2 ** 3) / (3 ** 2) .

For prefix unary operators, suppose we have the following pattern:

where OP1 is a prefix unary operator and OP2 is a binary operator. If OP1 has higher precedence than OP2 , then it would be grouped as (OP1 a) OP2 b ; otherwise, it would be OP1 (a OP2 b) .

If the unary operator is on the second operand:

Then the binary operator OP2 must have lower precedence than the unary operator OP1 for it to be grouped as a OP2 (OP1 b) . For example, the following is invalid:

Because + has higher precedence than yield , this would become (a + yield) 1 — but because yield is a reserved word in generator functions, this would be a syntax error. Luckily, most unary operators have higher precedence than binary operators and do not suffer from this pitfall.

If we have two prefix unary operators:

Then the unary operator closer to the operand, OP2 , must have higher precedence than OP1 for it to be grouped as OP1 (OP2 a) . It's possible to get it the other way and end up with (OP1 OP2) a :

Because await has higher precedence than yield , this would become (await yield) 1 , which is awaiting an identifier called yield , and a syntax error. Similarly, if you have new !A; , because ! has lower precedence than new , this would become (new !) A , which is obviously invalid. (This code looks nonsensical to write anyway, since !A always produces a boolean, not a constructor function.)

For postfix unary operators (namely, ++ and -- ), the same rules apply. Luckily, both operators have higher precedence than any binary operator, so the grouping is always what you would expect. Moreover, because ++ evaluates to a value , not a reference , you can't chain multiple increments together either, as you may do in C.

Operator precedence will be handled recursively . For example, consider this expression:

First, we group operators with different precedence by decreasing levels of precedence.

• The ** operator has the highest precedence, so it's grouped first.
• Looking around the ** expression, it has * on the right and + on the left. * has higher precedence, so it's grouped first. * and / have the same precedence, so we group them together for now.
• Looking around the * / / expression grouped in 2, because + has higher precedence than >> , the former is grouped.

Within the * / / group, because they are both left-associative, the left operand would be grouped.

Note that operator precedence and associativity only affect the order of evaluation of operators (the implicit grouping), but not the order of evaluation of operands . The operands are always evaluated from left-to-right. The higher-precedence expressions are always evaluated first, and their results are then composed according to the order of operator precedence.

If you are familiar with binary trees, think about it as a post-order traversal .

After all operators have been properly grouped, the binary operators would form a binary tree. Evaluation starts from the outermost group — which is the operator with the lowest precedence ( / in this case). The left operand of this operator is first evaluated, which may be composed of higher-precedence operators (such as a call expression echo("left", 4) ). After the left operand has been evaluated, the right operand is evaluated in the same fashion. Therefore, all leaf nodes — the echo() calls — would be visited left-to-right, regardless of the precedence of operators joining them.

Short-circuiting

In the previous section, we said "the higher-precedence expressions are always evaluated first" — this is generally true, but it has to be amended with the acknowledgement of short-circuiting , in which case an operand may not be evaluated at all.

Short-circuiting is jargon for conditional evaluation. For example, in the expression a && (b + c) , if a is falsy , then the sub-expression (b + c) will not even get evaluated, even if it is grouped and therefore has higher precedence than && . We could say that the logical AND operator ( && ) is "short-circuited". Along with logical AND, other short-circuited operators include logical OR ( || ), nullish coalescing ( ?? ), and optional chaining ( ?. ).

When evaluating a short-circuited operator, the left operand is always evaluated. The right operand will only be evaluated if the left operand cannot determine the result of the operation.

Note: The behavior of short-circuiting is baked in these operators. Other operators would always evaluate both operands, regardless if that's actually useful — for example, NaN * foo() will always call foo , even when the result would never be something other than NaN .

The previous model of a post-order traversal still stands. However, after the left subtree of a short-circuiting operator has been visited, the language will decide if the right operand needs to be evaluated. If not (for example, because the left operand of || is already truthy), the result is directly returned without visiting the right subtree.

Consider this case:

Only C() is evaluated, despite && having higher precedence. This does not mean that || has higher precedence in this case — it's exactly because (B() && A()) has higher precedence that causes it to be neglected as a whole. If it's re-arranged as:

Then the short-circuiting effect of && would only prevent C() from being evaluated, but because A() && C() as a whole is false , B() would still be evaluated.

However, note that short-circuiting does not change the final evaluation outcome. It only affects the evaluation of operands , not how operators are grouped — if evaluation of operands doesn't have side effects (for example, logging to the console, assigning to variables, throwing an error), short-circuiting would not be observable at all.

The assignment counterparts of these operators ( &&= , ||= , ??= ) are short-circuited as well. They are short-circuited in a way that the assignment does not happen at all.

The following table lists operators in order from highest precedence (18) to lowest precedence (1).

Several general notes about the table:

• Not all syntax included here are "operators" in the strict sense. For example, spread ... and arrow => are typically not regarded as operators. However, we still included them to show how tightly they bind compared to other operators/expressions.
• Some operators have certain operands that require expressions narrower than those produced by higher-precedence operators. For example, the right-hand side of member access . (precedence 17) must be an identifier instead of a grouped expression. The left-hand side of arrow => (precedence 2) must be an arguments list or a single identifier instead of some random expression.
• Some operators have certain operands that accept expressions wider than those produced by higher-precedence operators. For example, the bracket-enclosed expression of bracket notation [ … ] (precedence 17) can be any expression, even comma (precedence 1) joined ones. These operators act as if that operand is "automatically grouped". In this case we will omit the associativity.

• The operand can be any expression.
• The "right-hand side" must be an identifier.
• The "right-hand side" can be any expression.
• The "right-hand side" is a comma-separated list of any expression with precedence > 1 (i.e. not comma expressions). The constructor of a new expression cannot be an optional chain.
• The operand must be a valid assignment target (identifier or property access). Its precedence means new Foo++ is (new Foo)++ (a syntax error) and not new (Foo++) (a TypeError: (Foo++) is not a constructor).
• The operand must be a valid assignment target (identifier or property access).
• The operand cannot be an identifier or a private property access.
• The left-hand side cannot have precedence 14.
• The operands cannot be a logical OR || or logical AND && operator without grouping.
• The "left-hand side" must be a valid assignment target (identifier or property access).
• The associativity means the two expressions after ? are implicitly grouped.
• The "left-hand side" is a single identifier or a parenthesized parameter list.
• Only valid inside object literals, array literals, or argument lists.

The precedence of groups 17 and 16 may be a bit ambiguous. Here are a few examples to clarify.

• Optional chaining is always substitutable for its respective syntax without optionality (barring a few special cases where optional chaining is forbidden). For example, any place that accepts a?.b also accepts a.b and vice versa, and similarly for a?.() , a() , etc.
• Member expressions and computed member expressions are always substitutable for each other.
• Call expressions and import() expressions are always substitutable for each other.
• The "left-hand side" of a member access can be: a member access ( a.b.c ), new with arguments ( new a().b ), and function call ( a().b ).
• The "left-hand side" of new with arguments can be: a member access ( new a.b() ) and new with arguments ( new new a()() ).
• The "left-hand side" of a function call can be: a member access ( a.b() ), new with arguments ( new a()() ), and function call ( a()() ).
• The operand of new without arguments can be: a member access ( new a.b ), new with arguments ( new new a() ), and new without arguments ( new new a ).

6.1 — Operator precedence and associativity

Best practice

Value computation (of operations)

We know from the precedence and associativity rules above that this expression will be grouped as if we had typed:

• RecentChanges

Operator precedence determines how operators are parsed concerning each other. Operators with higher precedence become the operands of operators with lower precedence.

Precedence And Associativity

Consider an expression describable by the representation below, where both OP1 and OP2 are fill-in-the-blanks for OPerators.

The combination above has two possible interpretations:

Which one the language decides to adopt depends on the identity of OP1 and OP2 .

If OP1 and OP2 have different precedence levels (see the table below), the operator with the higher precedence goes first and associativity does not matter. Observe how multiplication has higher precedence than addition and executed first, even though addition is written first in the code.

Within operators of the same precedence, the language groups them by associativity . Left-associativity (left-to-right) means that it is interpreted as (a OP1 b) OP2 c , while right-associativity (right-to-left) means it is interpreted as a OP1 (b OP2 c) . Assignment operators are right-associative, so you can write:

with the expected result that a and b get the value 5. This is because the assignment operator returns the value that is assigned. First, b is set to 5. Then the a is also set to 5 — the return value of b = 5 , a.k.a. right operand of the assignment.

As another example, the unique exponentiation operator has right-associativity, whereas other arithmetic operators have left-associativity.

Operators are first grouped by precedence, and then, for adjacent operators that have the same precedence, by associativity. So, when mixing division and exponentiation, the exponentiation always comes before the division. For example, 2 ** 3 / 3 ** 2 results in 0.8888888888888888 because it is the same as (2 ** 3) / (3 ** 2) .

For prefix unary operators, suppose we have the following pattern:

where OP1 is a prefix unary operator and OP2 is a binary operator. If OP1 has higher precedence than OP2 , then it would be grouped as (OP1 a) OP2 b ; otherwise, it would be OP1 (a OP2 b) .

If the unary operator is on the second operand:

Then the binary operator OP2 must have lower precedence than the unary operator OP1 for it to be grouped as a OP2 (OP1 b) . For example, the following is invalid:

Because + has higher precedence than yield , this would become (a + yield) 1 — but because yield is a reserved word in generator functions, this would be a syntax error. Luckily, most unary operators have higher precedence than binary operators and do not suffer from this pitfall.

If we have two prefix unary operators:

Then the unary operator closer to the operand, OP2 , must have higher precedence than OP1 for it to be grouped as OP1 (OP2 a) . It's possible to get it the other way and end up with (OP1 OP2) a :

Because await has higher precedence than yield , this would become (await yield) 1 , which is awaiting an identifier called yield , and a syntax error. Similarly, if you have new !A; , because ! has lower precedence than new , this would become (new !) A , which is obviously invalid. (This code looks nonsensical to write anyway, since !A always produces a boolean, not a constructor function.)

For postfix unary operators (namely, ++ and -- ), the same rules apply. Luckily, both operators have higher precedence than any binary operator, so the grouping is always what you would expect. Moreover, because ++ evaluates to a value , not a reference , you can't chain multiple increments together either, as you may do in C.

Operator precedence will be handled recursively . For example, consider this expression:

First, we group operators with different precedence by decreasing levels of precedence.

• The ** operator has the highest precedence, so it's grouped first.
• Looking around the ** expression, it has * on the right and + on the left. * has higher precedence, so it's grouped first. * and / have the same precedence, so we group them together for now.
• Looking around the * / / expression grouped in 2, because + has higher precedence than >> , the former is grouped.

Within the * / / group, because they are both left-associative, the left operand would be grouped.

Note that operator precedence and associativity only affect the order of evaluation of operators (the implicit grouping), but not the order of evaluation of operands . The operands are always evaluated from left-to-right. The higher-precedence expressions are always evaluated first, and their results are then composed according to the order of operator precedence.

If you are familiar with binary trees, think about it as a post-order traversal .

After all operators have been properly grouped, the binary operators would form a binary tree. Evaluation starts from the outermost group — which is the operator with the lowest precedence ( / in this case). The left operand of this operator is first evaluated, which may be composed of higher-precedence operators (such as a call expression echo("left", 4) ). After the left operand has been evaluated, the right operand is evaluated in the same fashion. Therefore, all leaf nodes — the echo() calls — would be visited left-to-right, regardless of the precedence of operators joining them.

Short-circuiting

In the previous section, we said "the higher-precedence expressions are always evaluated first" — this is generally true, but it has to be amended with the acknowledgement of short-circuiting , in which case an operand may not be evaluated at all.

Short-circuiting is jargon for conditional evaluation. For example, in the expression a && (b + c) , if a is , then the sub-expression (b + c) will not even get evaluated, even if it is grouped and therefore has higher precedence than && . We could say that the logical AND operator ( && ) is "short-circuited". Along with logical AND, other short-circuited operators include logical OR ( || ), nullish coalescing ( ?? ), and optional chaining ( ?. ).

When evaluating a short-circuited operator, the left operand is always evaluated. The right operand will only be evaluated if the left operand cannot determine the result of the operation.

Note: The behavior of short-circuiting is baked in these operators. Other operators would always evaluate both operands, regardless if that's actually useful — for example, NaN * foo() will always call foo , even when the result would never be something other than NaN .

The previous model of a post-order traversal still stands. However, after the left subtree of a short-circuiting operator has been visited, the language will decide if the right operand needs to be evaluated. If not (for example, because the left operand of || is already truthy), the result is directly returned without visiting the right subtree.

Consider this case:

Only C() is evaluated, despite && having higher precedence. This does not mean that || has higher precedence in this case — it's exactly because (B() && A()) has higher precedence that causes it to be neglected as a whole. If it's re-arranged as:

Then the short-circuiting effect of && would only prevent C() from being evaluated, but because A() && C() as a whole is false , B() would still be evaluated.

However, note that short-circuiting does not change the final evaluation outcome. It only affects the evaluation of operands , not how operators are grouped — if evaluation of operands doesn't have side effects (for example, logging to the console, assigning to variables, throwing an error), short-circuiting would not be observable at all.

The assignment counterparts of these operators ( &&= , ||= , ??= ) are short-circuited as well. They are short-circuited in a way that the assignment does not happen at all.

The following table lists operators in order from highest precedence (18) to lowest precedence (1).

Several notes about the table:

• Not all syntax included here are "operators" in the strict sense. For example, spread ... and arrow => are typically not regarded as operators. However, we still included them to show how tightly they bind compared to other operators/expressions.
• The left operand of an exponentiation ** (precedence 13) cannot be one of the unary operators with precedence 14 without grouping, or there will be a SyntaxError . That means, although -1 ** 2 is technically unambiguous, the language requires you to use (-1) ** 2 instead.
• The operands of nullish coalescing ?? (precedence 3) cannot be a logical OR || (precedence 3) or logical AND && (precedence 4). That means you have to write (a ?? b) || c or a ?? (b || c) , instead of a ?? b || c .
• Some operators have certain operands that require expressions narrower than those produced by higher-precedence operators. For example, the right-hand side of member access . (precedence 17) must be an identifier instead of a grouped expression. The left-hand side of arrow => (precedence 2) must be an arguments list or a single identifier instead of some random expression.
• Some operators have certain operands that accept expressions wider than those produced by higher-precedence operators. For example, the bracket-enclosed expression of bracket notation [ … ] (precedence 17) can be any expression, even comma (precedence 1) joined ones. These operators act as if that operand is "automatically grouped". In this case we will omit the associativity.

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Assignment operators

• 8 contributors

expression assignment-operator expression

assignment-operator : one of   =   *=   /=   %=   +=   -=   <<=   >>=   &=   ^=   |=

Assignment operators store a value in the object specified by the left operand. There are two kinds of assignment operations:

simple assignment , in which the value of the second operand is stored in the object specified by the first operand.

compound assignment , in which an arithmetic, shift, or bitwise operation is performed before storing the result.

All assignment operators in the following table except the = operator are compound assignment operators.

Assignment operators table

Operator keywords

Three of the compound assignment operators have keyword equivalents. They are:

C++ specifies these operator keywords as alternative spellings for the compound assignment operators. In C, the alternative spellings are provided as macros in the <iso646.h> header. In C++, the alternative spellings are keywords; use of <iso646.h> or the C++ equivalent <ciso646> is deprecated. In Microsoft C++, the /permissive- or /Za compiler option is required to enable the alternative spelling.

Simple assignment

The simple assignment operator ( = ) causes the value of the second operand to be stored in the object specified by the first operand. If both objects are of arithmetic types, the right operand is converted to the type of the left, before storing the value.

Objects of const and volatile types can be assigned to l-values of types that are only volatile , or that aren't const or volatile .

Assignment to objects of class type ( struct , union , and class types) is performed by a function named operator= . The default behavior of this operator function is to perform a member-wise copy assignment of the object's non-static data members and direct base classes; however, this behavior can be modified using overloaded operators. For more information, see Operator overloading . Class types can also have copy assignment and move assignment operators. For more information, see Copy constructors and copy assignment operators and Move constructors and move assignment operators .

An object of any unambiguously derived class from a given base class can be assigned to an object of the base class. The reverse isn't true because there's an implicit conversion from derived class to base class, but not from base class to derived class. For example:

Assignments to reference types behave as if the assignment were being made to the object to which the reference points.

For class-type objects, assignment is different from initialization. To illustrate how different assignment and initialization can be, consider the code

The preceding code shows an initializer; it calls the constructor for UserType2 that takes an argument of type UserType1 . Given the code

the assignment statement

can have one of the following effects:

Call the function operator= for UserType2 , provided operator= is provided with a UserType1 argument.

Call the explicit conversion function UserType1::operator UserType2 , if such a function exists.

Call a constructor UserType2::UserType2 , provided such a constructor exists, that takes a UserType1 argument and copies the result.

Compound assignment

The compound assignment operators are shown in the Assignment operators table . These operators have the form e1 op = e2 , where e1 is a non- const modifiable l-value and e2 is:

an arithmetic type

a pointer, if op is + or -

a type for which there exists a matching operator *op*= overload for the type of e1

The built-in e1 op = e2 form behaves as e1 = e1 op e2 , but e1 is evaluated only once.

Compound assignment to an enumerated type generates an error message. If the left operand is of a pointer type, the right operand must be of a pointer type, or it must be a constant expression that evaluates to 0. When the left operand is of an integral type, the right operand must not be of a pointer type.

Result of built-in assignment operators

The built-in assignment operators return the value of the object specified by the left operand after the assignment (and the arithmetic/logical operation in the case of compound assignment operators). The resultant type is the type of the left operand. The result of an assignment expression is always an l-value. These operators have right-to-left associativity. The left operand must be a modifiable l-value.

In ANSI C, the result of an assignment expression isn't an l-value. That means the legal C++ expression (a += b) += c isn't allowed in C.

Expressions with binary operators C++ built-in operators, precedence, and associativity C assignment operators

Was this page helpful?

Additional resources

C Programming Tutorial

• Assignment Operator in C

Last updated on July 27, 2020

We have already used the assignment operator ( = ) several times before. Let's discuss it here in detail. The assignment operator ( = ) is used to assign a value to the variable. Its general format is as follows:

The operand on the left side of the assignment operator must be a variable and operand on the right-hand side must be a constant, variable or expression. Here are some examples:

The precedence of the assignment operator is lower than all the operators we have discussed so far and it associates from right to left.

We can also assign the same value to multiple variables at once.

here x , y and z are initialized to 100 .

Since the associativity of the assignment operator ( = ) is from right to left. The above expression is equivalent to the following:

Note that expressions like:

are called assignment expression. If we put a semicolon( ; ) at the end of the expression like this:

then the assignment expression becomes assignment statement.

Compound Assignment Operator #

Assignment operations that use the old value of a variable to compute its new value are called Compound Assignment.

Consider the following two statements:

Here the second statement adds 5 to the existing value of x . This value is then assigned back to x . Now, the new value of x is 105 .

To handle such operations more succinctly, C provides a special operator called Compound Assignment operator.

The general format of compound assignment operator is as follows:

where op can be any of the arithmetic operators ( + , - , * , / , % ). The above statement is functionally equivalent to the following:

Note : In addition to arithmetic operators, op can also be >> (right shift), << (left shift), | (Bitwise OR), & (Bitwise AND), ^ (Bitwise XOR). We haven't discussed these operators yet.

After evaluating the expression, the op operator is then applied to the result of the expression and the current value of the variable (on the RHS). The result of this operation is then assigned back to the variable (on the LHS). Let's take some examples: The statement:

is equivalent to x = x + 5; or x = x + (5); .

Similarly, the statement:

is equivalent to x = x * 2; or x = x * (2); .

Since, expression on the right side of op operator is evaluated first, the statement:

is equivalent to x = x * (y + 1) .

The precedence of compound assignment operators are same and they associate from right to left (see the precedence table ).

The following table lists some Compound assignment operators:

The following program demonstrates Compound assignment operators in action:

Expected Output:

Load Comments

• Intro to C Programming
• Installing Code Blocks
• Creating and Running The First C Program
• Basic Elements of a C Program
• Keywords and Identifiers
• Data Types in C
• Constants in C
• Variables in C
• Input and Output in C
• Formatted Input and Output in C
• Arithmetic Operators in C
• Operator Precedence and Associativity in C
• Increment and Decrement Operators in C
• Relational Operators in C
• Logical Operators in C
• Conditional Operator, Comma operator and sizeof() operator in C
• Implicit Type Conversion in C
• Explicit Type Conversion in C
• if-else statements in C
• The while loop in C
• The do while loop in C
• The for loop in C
• The Infinite Loop in C
• The break and continue statement in C
• The Switch statement in C
• Function basics in C
• The return statement in C
• Actual and Formal arguments in C
• Local, Global and Static variables in C
• Recursive Function in C
• One dimensional Array in C
• One Dimensional Array and Function in C
• Two Dimensional Array in C
• Pointer Basics in C
• Pointer Arithmetic in C
• Pointers and 1-D arrays
• Pointers and 2-D arrays
• Call by Value and Call by Reference in C
• Returning more than one value from function in C
• Returning a Pointer from a Function in C
• Passing 1-D Array to a Function in C
• Passing 2-D Array to a Function in C
• Array of Pointers in C
• Void Pointers in C
• The malloc() Function in C
• The calloc() Function in C
• The realloc() Function in C
• String Basics in C
• The strlen() Function in C
• The strcmp() Function in C
• The strcpy() Function in C
• The strcat() Function in C
• Character Array and Character Pointer in C
• Array of Strings in C
• Array of Pointers to Strings in C
• The sprintf() Function in C
• The sscanf() Function in C
• Structure Basics in C
• Array of Structures in C
• Array as Member of Structure in C
• Nested Structures in C
• Pointer to a Structure in C
• Pointers as Structure Member in C
• Structures and Functions in C
• Union Basics in C
• typedef statement in C
• Basics of File Handling in C
• fputc() Function in C
• fgetc() Function in C
• fputs() Function in C
• fgets() Function in C
• fprintf() Function in C
• fscanf() Function in C
• fwrite() Function in C
• fread() Function in C

Recent Posts

• Machine Learning Experts You Should Be Following Online
• 4 Ways to Prepare for the AP Computer Science A Exam
• Finance Assignment Online Help for the Busy and Tired Students: Get Help from Experts
• Top 9 Machine Learning Algorithms for Data Scientists
• Data Science Learning Path or Steps to become a data scientist Final
• Enable Edit Button in Shutter In Linux Mint 19 and Ubuntu 18.04
• Python 3 time module
• Pygments Tutorial
• How to use Virtualenv?
• Installing MySQL (Windows, Linux and Mac)
• What is if __name__ == '__main__' in Python ?
• Installing GoAccess (A Real-time web log analyzer)
• Installing Isso

cppreference.com

Assignment operators.

Assignment and compound assignment operators are binary operators that modify the variable to their left using the value to their right.

[ edit ] Simple assignment

The simple assignment operator expressions have the form

Assignment performs implicit conversion from the value of rhs to the type of lhs and then replaces the value in the object designated by lhs with the converted value of rhs .

Assignment also returns the same value as what was stored in lhs (so that expressions such as a = b = c are possible). The value category of the assignment operator is non-lvalue (so that expressions such as ( a = b ) = c are invalid).

rhs and lhs must satisfy one of the following:

• both lhs and rhs have compatible struct or union type, or..
• rhs must be implicitly convertible to lhs , which implies
• both lhs and rhs have arithmetic types , in which case lhs may be volatile -qualified or atomic (since C11)
• both lhs and rhs have pointer to compatible (ignoring qualifiers) types, or one of the pointers is a pointer to void, and the conversion would not add qualifiers to the pointed-to type. lhs may be volatile or restrict (since C99) -qualified or atomic (since C11) .
• lhs is a (possibly qualified or atomic (since C11) ) pointer and rhs is a null pointer constant such as NULL or a nullptr_t value (since C23)

[ edit ] Notes

If rhs and lhs overlap in memory (e.g. they are members of the same union), the behavior is undefined unless the overlap is exact and the types are compatible .

Although arrays are not assignable, an array wrapped in a struct is assignable to another object of the same (or compatible) struct type.

The side effect of updating lhs is sequenced after the value computations, but not the side effects of lhs and rhs themselves and the evaluations of the operands are, as usual, unsequenced relative to each other (so the expressions such as i = ++ i ; are undefined)

Assignment strips extra range and precision from floating-point expressions (see FLT_EVAL_METHOD ).

In C++, assignment operators are lvalue expressions, not so in C.

[ edit ] Compound assignment

The compound assignment operator expressions have the form

The expression lhs @= rhs is exactly the same as lhs = lhs @ ( rhs ) , except that lhs is evaluated only once.

[ edit ] References

• C17 standard (ISO/IEC 9899:2018):
• 6.5.16 Assignment operators (p: 72-73)
• C11 standard (ISO/IEC 9899:2011):
• 6.5.16 Assignment operators (p: 101-104)
• C99 standard (ISO/IEC 9899:1999):
• 6.5.16 Assignment operators (p: 91-93)
• C89/C90 standard (ISO/IEC 9899:1990):
• 3.3.16 Assignment operators

[ edit ] See Also

Operator precedence

[ edit ] See also

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 19 August 2022, at 09:36.
• Privacy policy
• About cppreference.com
• Disclaimers

Learn Python practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn python interactively, introduction.

• Your First C# Program
• C# Comments
• C# Variables and (Primitive) Data Types

C# Operators

• C# Basic Input and Output
• C# Expressions, Statements and Blocks

Flow Control

C# if, if...else, if...else if and Nested if Statement

C# ternary (? :) Operator

• C# for loop
• C# while and do...while loop
• Nested Loops in C#: for, while, do-while
• C# break Statement
• C# continue Statement
• C# switch Statement
• C# Multidimensional Array
• C# Jagged Array
• C# foreach loop
• C# Class and Object
• C# Access Modifiers
• C# Variable Scope
• C# Constructor
• C# this Keyword
• C# Destructor
• C# static Keyword
• C# Inheritance
• C# abstract class and method
• C# Nested Class
• C# Partial Class and Partial Method
• C# sealed class and method
• C# interface
• C# Polymorphism
• C# Method Overloading
• C# Constructor Overloading

Exception Handling

• C# Exception and Its Types
• C# Exception Handling
• C# Collections
• C# ArrayList
• C# SortedList
• C# Hashtable
• C# Dictionary
• C# Recursion
• C# Lambda Expression
• C# Anonymous Types
• C# Generics
• C# Iterators
• C# Delegates
• C# Indexers
• C# Regular Expressions

Additional Topics

• C# Keywords and Identifiers
• C# Type Conversion

C# Operator Precedence and Associativity

C# Bitwise and Bit Shift Operators

• C# using Directive
• C# Preprocessor Directives
• Namespaces in C# Programming
• C# Nullable Types
• C# yield keyword
• C# Reflection

C# Tutorials

• C# Expressions, Statements and Blocks (With Examples)

C# Operator Precedence

Operator precedence is a set of rules which defines how an expression is evaluated. In C#, each C# operator has an assigned priority and based on these priorities, the expression is evaluated.

For example , the precedence of multiplication (*) operator is higher than the precedence of addition (+) operator. Therefore, operation involving multiplication is carried out before addition.

Take a look at the statement below.

What will be the value of x after executing this statement?

The operand 3 is associated with + and * . As stated earlier, multiplication has a higher precedence than addition. So, the operation 3 * 5 is carried out instead of 4 + 3 . The value of variable x will be 19 .

If addition would have a higher precedence, 4 + 3 would be evaluated first and the value of x would be 35 .

• Operator Precedence Table

The higher the precedence of operator is, the higher it appears in the table

The assignment operators have the lowest precedence while the postfix increment and decrement operators have the highest precedence.

• Example 1: Operator Precedence

When we run the program, the output will be:

Let's understand how the expression is evaluated in the program.

The precedence of -- and ++ is higher than * , and precedence of * is higher than - . Hence the statement,

is equivalent to

The expression inside parentheses is always evaluated first no matter what the precedence of operators outside it is.

• Hence the final value of result1 will be 19 .

In the next expression, the precedence of + is higher than >= . So, c and a is added first and the sum is compared with b to produce false .

Associativity of Operators in C#

In the previous section, we discussed about operator precedence. If two operators with different precedence are used, the operator with higher precedence is evaluated first.

But what if both the operators have same precedence?

In such case, the expression is evaluated based on the associativity of operator (left to right or right to left).

For example:

Here, both * and / have the same precedence. But since the associativity of these operators is from left to right , a * b is evaluated first and then division is carried out. The final result of this expression will be 10 .

In this particular example, the associativity does not really matter. Because even if division was carried out before multiplication, the result would be unaffected.

Let's take a look at another example.

The associativity of = operator is from right to left . So the value of c (i.e. 3 ) is assigned to b , and then the value of b is assigned to a . So after executing this statement, the values of a , b and c will be 3 .

The table below shows the associativity of C# operators:

Almost all the operators have associativity from left to right. The operators having associativity from right to left are:

• Unary operators
• Prefix Increment and Decrement Operators
• Ternary Operator
• Assignment Operators

Example 2: Associativity of Operators

Table of contents.

• Operator Associativity Table
• Example 1: Operator Associativity

Sorry about that.

Our premium learning platform, created with over a decade of experience and thousands of feedbacks .

Learn and improve your coding skills like never before.

• Interactive Courses
• Certificates
• 2000+ Challenges

Related Tutorials

C# Tutorial

JS Tutorial

Js versions, js functions, js html dom, js browser bom, js web apis, js vs jquery, js graphics, js examples, js references, javascript operator precedence.

Operator precedence describes the order in which operations are performed in an arithmetic expression.

Multiplication ( * ) and division ( / ) have higher precedence than addition ( + ) and subtraction ( - ).

As in traditional mathematics, multiplication is done first:

When using parentheses, operations inside the parentheses are computed first:

Operations with the same precedence (like * and /) are computed from left to right:

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

JavaScript Operators and Operator Precedence – Beginner‘s Guide

JavaScript makes heavy use of operators to manipulate values and variables in code. As a beginner, grasping how these operators work and their order of evaluation can be confusing initially. In this comprehensive 2650+ words guide, we will cover all the key concepts you need to know about operators in JavaScript.

What are Operators in JavaScript?

Operators are special symbols or keywords that perform operations on operands (values and variables).

For example:

The value that the operator works on is called the operand . Operands can be literal values, variables, or more complex expressions that resolve to a value.

According to Code Frequency analysis of open-source JavaScript projects on Github, some of the most commonly used operators are:

This shows operators are extensively used in real-world JavaScript code.

Some broad categories of JavaScript operators include:

• Arithmetic operators
• Assignment operators
• Comparison operators
• Logical operators
• Bitwise operators

Later we will explain the most popular operators falling under these categories that every JavaScript developer should know.

Operator Precedence in JavaScript

Operator precedence determines the order in which operations get performed in expressions with multiple operators.

Certain operators have higher precedence than others. For example, the multiplication operator has a higher precedence than the addition operator.

Consider this example:

Here, the multiplication happens first before the addition because it has higher precedence. So 3 * 4 equals 12, then 2 gets added giving 14.

The overall order is:

• Parentheses
• Exponential
• Multiplication & Division (left-to-right)
• Addition & Subtraction (left-to-right)

Following this exact precedence order, JavaScript evaluates each expression from start to finish.

Understanding this flow helps avoid errors in complex statements with multiple operators. Getting it wrong can lead to unintended behavior.

Now let‘s dive deeper into the most popular JavaScript operator categories.

Types of Operators in JavaScript

JavaScript includes a diverse range of operators to perform different types of actions and operations. We will focus on the operators you need to know as a beginner.

1. Arithmetic Operators

These operators are used to perform common mathematical calculations:

This covers basic math operations like addition/subtraction to more complex ones like modulus, exponential, increment and decrement.

According to Code Frequency stats, the + and ++ operators appear in the top 10 most used operators in JavaScript code on Github.

Arithmetic operators take numerical values (either literals or variables) as their operands. By combining them, we can execute complex math in JavaScript.

2. Assignment Operators

The most basic assignment operator is = that assigns a value to a variable.

Some other assignment operators:

These operators first perform the arithmetic operation on current and new value, and assign the result back to the variable.

Assignment operators rank high in usage frequency – the basic = assignment operator is #3 most used across JavaScript projects per Code Frequency.

3. Comparison Operators

Comparison operators compare two operand values or expressions and return a boolean true / false result based on that condition.

The comparison operators supported in JavaScript are:

• Equal to (==)
• Strict equal to (===)
• Not equal to (!=)
• Strict not equal (!==)
• Greater than (>)
• Greater than or equal to (>=)
• Less than (<)
• Less than or equal to (<=)

Equal to (==) compares values only, while strict equal to (===) checks the value AND matches data type.

Using === avoids unexpected type coercions.

4. Logical Operators

Logical operators evaluate an expression and return a boolean true or false.

The logical operators are:

• Logical AND (&&)
• Logical OR (||)
• Logical NOT (!)

These allow creating complex boolean logic conditions in code.

5. Ternary Operator

The ternary or conditional operator assigns a value to a variable based on a condition.

It adheres to this syntax:

This acts as a shorthand for if-else statement in assigning values based on conditions.

Operator Precedence Revisited

We learned about different JavaScript operators. But what happens when an expression contains multiple operators? Operator precedence rules decide the order of evaluation.

Here, multiplication occurs before addition because it has higher precedence. So x equals 25 instead of 35.

The complete JavaScript operator precedence order is:

• Grouping – parentheses ()
• Negation/Increment operators (!, –, ++)
• Exponential (**)
• Multiplication/Division (*, /)
• Addition/Subtraction (+, -)
• Relational operators (<, <=, >, >=)
• Equality operators (==, !=, ===, !==)
• Assignment operators (=, +=, -= etc.)
• Comma Operator (,)

This precise precedence hierarchy is applied while evaluating expressions with multiple operators.

Understanding this order allows you to correctly reason about complex statements. Getting it wrong will lead to unintended behavior.

Examples of Operator Precedence

Let‘s breakdown a few examples in detail:

These examples clearly show how operator precedence can dramatically affect results.

Familiarity with these rules will let you interpret and debug complex code much more easily.

Getting precedence wrong is a common source of unexpected behavior and bugs in JavaScript code.

Common Operator Precedence Errors

Some typical errors that occur due to incorrect assumptions about operator precedence:

1. Incorrect string concatenation

2. Mathematical calculations go wrong

3. Incorrect boolean logic

These kinds of errors can be avoided by properly applying the operator precedence rules.

Using parentheses also helps in overriding default precedence when unsure.

Associativity of Operators

Associativity refers to the direction in which operators of the same precedence are evaluated.

Most JavaScript operators are left-to-right associative – they group left-to-right in the absence of parentheses.

But a few operators show right-to-left associativity – they group right-to-left direction.

For instance, the exponentiation operator (**) is right-to-left associative:

This behavior can cause mistakes if we assume left-to-right evaluation for everything.

So be aware of associativity rules to accurately reason about complex expressions.

Recommended Practices

When working extensively with operators, adopt these best practices:

• Use parentheses to explicitly dictate order, improves readability
• Break down large expressions into smaller components
• Use descriptive variable/function names
• Follow a consistent formatting style guide
• Add comments explaining complex logic flow and operations
• Use strict equality checks (===) instead of loose equality (==)
• Use template literals for string manipulation instead of concatenation
• Prefer increment/decrement operators (++/–) when possible

Cultivating these good habits early on will help avoid lots of pitfalls later in complex JavaScript applications.

New and Experimental Operators

JavaScript continues to evolve with newer ECMAScript standards introducing experimental features.

Some operators added recently:

1. Nullish Coalescing Operator (??)

The ?? operator returns the right-hand value when the left one is null or undefined.

2. Optional Chaining Operator (?.)

The ?. operator stops evaluation if trying to access non-existent property.

These experimental operators open new possibilities and use cases going forward.

In this comprehensive 2600+ words guide, we started by answering:

• What operators are and how they evaluate operands
• Different categories of operators like arithmetic, logical and more
• Operator precedence determines order of evaluation
• Examples showed precedence dramatically affects results

We then covered specifics of the most popular operators used in JavaScript:

• Arithmetic operators for math calculations
• Assignment operators to assign values
• Comparison operators return boolean result
• Logical operators combine boolean logic
• Ternary operator shorthands if-else conditional

And some key concepts like:

• Operator precedence order – which operator gets evaluated first
• Common mistakes due to incorrect assumptions
• Associativity rules – left-to-right or right-to-left
• Best practices for clean and optimized code

JavaScript operators provide the building blocks that power complex logic. Mastering them early on gives a major boost for becoming an efficient JavaScript programmer.

Of all the operator concepts covered, which one did you find most useful and why? Let me know in the comments!

Dr. Alex Mitchell is a dedicated coding instructor with a deep passion for teaching and a wealth of experience in computer science education. As a university professor, Dr. Mitchell has played a pivotal role in shaping the coding skills of countless students, helping them navigate the intricate world of programming languages and software development.

Beyond the classroom, Dr. Mitchell is an active contributor to the freeCodeCamp community, where he regularly shares his expertise through tutorials, code examples, and practical insights. His teaching repertoire includes a wide range of languages and frameworks, such as Python, JavaScript, Next.js, and React, which he presents in an accessible and engaging manner.

Dr. Mitchell’s approach to teaching blends academic rigor with real-world applications, ensuring that his students not only understand the theory but also how to apply it effectively. His commitment to education and his ability to simplify complex topics have made him a respected figure in both the university and online learning communities.

Similar Posts

How to Build an Accordion Menu Using HTML, CSS and JavaScript

Accordion menus are vertical stacks of headers that expand to reveal additional content. They conserve screen…

An Intuitive Guide to Convolutional Neural Networks: A Full-Stack Perspective

Photo by Toa Heftiba on Unsplash As a full-stack developer, being able to leverage convolutional neural…

How to Make Your Fancy SVG Button Accessible

Scalable Vector Graphics (SVG) offer enormous advantages for responsive web design. However, ensuring accessibility for complex…

How to Start a Freelance Dev Business

Freelance web development has grown tremendously, driven by remote work trends and booming demand for digital…

Routing in Next.js – A Comprehensive Guide to Dynamic Routing and Pre-Rendering

Next.js has become one of the most popular React frameworks for building web applications thanks to…

How To Write An Amazing Cover Letter That Will Get You Hired As A Developer (Template Included)

If the thought of writing a cover letter overwhelms you, you‘re not alone. Crafting the perfect…

• C Data Types
• C Operators
• C Input and Output
• C Control Flow
• C Functions
• C Preprocessors
• C File Handling
• C Cheatsheet
• C Interview Questions

Assignment Operators in C

Assignment operators are used for assigning value to a variable. The left side operand of the assignment operator is a variable and right side operand of the assignment operator is a value. The value on the right side must be of the same data-type of the variable on the left side otherwise the compiler will raise an error.

Different types of assignment operators are shown below:

1. “=”: This is the simplest assignment operator. This operator is used to assign the value on the right to the variable on the left. Example:

2. “+=” : This operator is combination of ‘+’ and ‘=’ operators. This operator first adds the current value of the variable on left to the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 5. Then (a += 6) = 11.

3. “-=” This operator is combination of ‘-‘ and ‘=’ operators. This operator first subtracts the value on the right from the current value of the variable on left and then assigns the result to the variable on the left. Example:

If initially value stored in a is 8. Then (a -= 6) = 2.

4. “*=” This operator is combination of ‘*’ and ‘=’ operators. This operator first multiplies the current value of the variable on left to the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 5. Then (a *= 6) = 30.

5. “/=” This operator is combination of ‘/’ and ‘=’ operators. This operator first divides the current value of the variable on left by the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 6. Then (a /= 2) = 3.

Below example illustrates the various Assignment Operators:

Please Login to comment...

Similar reads.

• C-Operators
• cpp-operator
• How to Delete Discord Servers: Step by Step Guide
• Google increases YouTube Premium price in India: Check our the latest plans
• California Lawmakers Pass Bill to Limit AI Replicas
• Best 10 IPTV Service Providers in Germany
• 15 Most Important Aptitude Topics For Placements [2024]

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• Onsite training

3,000,000+ delegates

15,000+ clients

1,000+ locations

• KnowledgePass
• Log a ticket

01344203999 Available 24/7

Operators in C Programming: A Complete Overview

Curious about Operators in C Programming? Operators in C are symbols that perform operations on variables and values, such as addition, subtraction, and comparison. This blog will delve into various operators, including arithmetic, logical, and bitwise, explaining their functions and how they are used in C programming.

Exclusive 40% OFF

Training Outcomes Within Your Budget!

We ensure quality, budget-alignment, and timely delivery by our expert instructors.

Share this Resource

• Introduction of Embedded C Programming
• C# and .NET Training
• C# Engineer Training
• C++ Programming (C Plus Plus)

Are you struggling to master the foundational concepts of programming? Understanding operators in C programming is crucial for anyone looking to write efficient and powerful code. These operators are the building blocks that enable you to perform calculations, manipulate data, and make decisions within your programs. 

In this blog, we'll delve into the various types of operators in C programming, from arithmetic to logical, and explore how they work together to bring your code to life. By mastering these operators, you'll gain the confidence to tackle more complex programming challenges, making your code both cleaner and more effective. Stay with us as we guide you through the essentials of operators in C programming, helping you unlock the true potential of your coding skills. 

Table of Contents 

1) What is a C Operator? 

2) Types of Operators in C 

   a) Arithmetic Operations in C 

   b) Relational Operators in C 

   c) Logical Operator in C 

   d) Bitwise Operators in C 

   e) Assignment Operators in C 

   f) Increment and Decrement Operators 

   g) sizeof Operator 

   h) Other Operators 

3) Conclusion 

What is a C Operator? 

In C Programming, an operator is a symbol that instructs the compiler to perform specific mathematical, relational, or logical operations on variables and values to produce a result. Operators are fundamental in manipulating data and are used extensively in expressions to perform calculations, comparisons, and logical evaluations.  

They enable programmers to write concise and efficient code by simplifying complex operations into manageable components. From simple arithmetic operations like addition and subtraction to more complex tasks like bitwise manipulations and logical decision-making, operators in C are essential tools that facilitate a wide range of programming tasks and functionalities.  

Types of Operators in C 

C Operators are categorised based on the type of operation they perform. These categories include arithmetic, relational, logical, sbitwise, assignment, increment and decrement, size of, and other miscellaneous operators. Each category has specific functions and uses in programming. Understanding these operators in conjunction with the various Data Types in C allows programmers to effectively manipulate and process data. 

1) Arithmetic Operations in C 

Arithmetic operators perform basic mathematical operations such as addition, subtraction, multiplication, division, and modulus. 

Operators and Their Functions: 

a) + (Addition): Adds two operands. 

b) - (Subtraction): Subtracts the second operand from the first. 

c) * (Multiplication): Multiplies two operands. 

d) / (Division): Divides the numerator by the denominator. 

e) % (Modulus): Returns the remainder of a division operation. 

Example:  

Boost your programming skills—join our C Programming Trainings today and become an expert coder!  

2) Relational Operators in C 

Relational operators compare two values or variables. They return a boolean result (true or false). 

a) == (Equal to): Checks if two operands are equal. 

b) != (Not equal to): Checks if two operands are not equal. 

c) > (Greater than): Checks if the left operand is greater than the right. 

d) < (Less than): Checks if the left operand is less than the right. 

e) >= (Greater than or equal to): Checks if the left operand is greater than or equal to the right. 

f) <= (Less than or equal to): Checks if the left operand is less than or equal to the right. 

3) Logical Operators in C 

Logical operators are used to combine multiple relational expressions. 

a) && (Logical AND): Returns true if both operands are true. 

b) || (Logical OR): Returns true if at least one operand is true. 

c) ! (Logical NOT): Returns true if the operand is false. 

Master the fundamentals of coding—Join our C Programming Course today!  

4) Bitwise Operators in C 

Bitwise operators perform operations on binary representations of integers. 

a) & (AND): Performs bitwise AND. 

b) | (OR): Performs bitwise OR. 

c) ^ (XOR): Performs bitwise XOR. 

d) ~ (NOT): Performs bitwise NOT. 

e) << (Left Shift): Shifts bits to the left. 

f) >> (Right Shift): Shifts bits to the right. 

5) Assignment Operators in C 

Assignment operators assign values to variables. 

a) =: Simple assignment. 

b) +=: Adds and assigns. 

c) -=: Subtracts and assigns. 

d) *=: Multiplies and assigns. 

e) /=: Divides and assigns. 

f)  %=: Takes modulus and assigns. 

6) Increment and Decrement Operators 

Increment and decrement operators increase or decrease the value of a variable by one. 

a) ++: Increment operator. 

b) --: Decrement operator. 

Take your coding skills to the next level—Register for our C++ Programming Course today!  

7) sizeof Operator 

The sizeof operator returns the size of a variable or data type in bytes. 

8) Other Operators 

Other miscellaneous operators include the comma operator, the conditional operator (ternary), and the cast operator. 

a) , (Comma): Separates expressions. 

b)  ?: (Ternary): A shorthand for the if-else statement. 

c) (type) (Cast): Converts a variable from one type to another. 

Example :  

Conclusion 

Understanding and effectively using operators in C programming is crucial for writing efficient and effective code. By mastering these operators, you can perform a wide range of operations, from simple arithmetic to complex bitwise manipulations, enhancing your programming capabilities. 

Transform your career—Join  our C# and .NET Training today and master the skills needed to build robust applications!  

Frequently Asked Questions

Operators in C are symbols that instruct the compiler to perform specific mathematical, relational, or logical operations on variables and values. They enable manipulation of data, facilitating various operations such as arithmetic calculations, comparisons, and logical evaluations, which are essential for writing functional C programs.  

The '=' operator is an assignment operator that assigns the value on its right to the variable on its left. The '==' operator is a relational operator used to compare two values, returning true if they are equal and false if they are not. 

Logic operators in C include && (logical AND), || (logical OR), and ! (logical NOT). These operators are used to combine or invert logical expressions, enabling decision-making processes within the program based on multiple conditions.  

The Knowledge Academy takes global learning to new heights, offering over 30,000 online courses across 490+ locations in 220 countries. This expansive reach ensures accessibility and convenience for learners worldwide.  

Alongside our diverse Online Course Catalogue, encompassing 17 major categories, we go the extra mile by providing a plethora of free educational Online Resources like News updates, Blogs , videos, webinars, and interview questions. Tailoring learning experiences further, professionals can maximise value with customisable Course Bundles of TKA .  

The Knowledge Academy’s Knowledge Pass , a prepaid voucher, adds another layer of flexibility, allowing course bookings over a 12-month period. Join us on a journey where education knows no bounds.  

The Knowledge Academy offers various C Programming Courses , including the E C# Programming Course, C Programming Course and the C++ Programming Training. These courses cater to different skill levels, providing comprehensive insights into C vs Java .  

Our Programming and DevOps Blogs cover a range of topics related to C Programming, offering valuable resources, best practices, and industry insights. Whether you are a beginner or looking to advance your Programming skills, The Knowledge Academy's diverse courses and informative blogs have got you covered.  

Upcoming Programming & DevOps Resources Batches & Dates

Thu 19th Sep 2024

Thu 19th Dec 2024

Get A Quote

WHO WILL BE FUNDING THE COURSE?

My employer

By submitting your details you agree to be contacted in order to respond to your enquiry

• Business Analysis
• Lean Six Sigma Certification

Share this course

Our biggest summer sale.

We cannot process your enquiry without contacting you, please tick to confirm your consent to us for contacting you about your enquiry.

By submitting your details you agree to be contacted in order to respond to your enquiry.

We may not have the course you’re looking for. If you enquire or give us a call on 01344203999 and speak to our training experts, we may still be able to help with your training requirements.

Or select from our popular topics

• ITIL® Certification
• Scrum Certification
• ISO 9001 Certification
• Change Management Certification
• Microsoft Azure Certification
• Microsoft Excel Courses
• Explore more courses

Press esc to close

Fill out your  contact details  below and our training experts will be in touch.

Fill out your   contact details   below

Thank you for your enquiry!

One of our training experts will be in touch shortly to go over your training requirements.

Back to Course Information

Fill out your contact details below so we can get in touch with you regarding your training requirements.

* WHO WILL BE FUNDING THE COURSE?

Preferred Contact Method

No preference

Back to course information

Fill out your  training details  below

Fill out your training details below so we have a better idea of what your training requirements are.

HOW MANY DELEGATES NEED TRAINING?

HOW DO YOU WANT THE COURSE DELIVERED?

Online Instructor-led

Online Self-paced

WHEN WOULD YOU LIKE TO TAKE THIS COURSE?

Next 2 - 4 months

WHAT IS YOUR REASON FOR ENQUIRING?

Looking for some information

Looking for a discount

I want to book but have questions

One of our training experts will be in touch shortly to go overy your training requirements.

Your privacy & cookies!

Like many websites we use cookies. We care about your data and experience, so to give you the best possible experience using our site, we store a very limited amount of your data. Continuing to use this site or clicking “Accept & close” means that you agree to our use of cookies. Learn more about our privacy policy and cookie policy cookie policy .

We use cookies that are essential for our site to work. Please visit our cookie policy for more information. To accept all cookies click 'Accept & close'.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Post-increment vs Assignment in C++ operation precedence table

I stumbled upon https://en.cppreference.com/w/cpp/language/operator_precedence

On the chart, I see that post-increment operator (++) is way above assignment operator (=).

However, I know that

I always take it for grant that post-increment happens after the assignment operator. However, if I follow the operation precedence chart, then isn't post-increment suppose to happen before = operation? Isn't the answer suppose to be a={10, 5} rather than a={5, 20} ?

• operator-precedence

• Instead of using int to examine the sequential behavior of the operators applied, you might write a test class overloading all these operators in question. –  πάντα ῥεῖ Commented Mar 10, 2019 at 8:58

3 Answers 3

"Precedence" is misleading. It has little to do in general with evaluation order (what happens first), but instead determines what is the operand of each operator for the purpose of evaluation. But let's examine your example.

This means that 5 is to be assigned to the lvalue on the left. And since C++17, we know that 5 is evaluated entirely before *(b++) . Prior to that, they could be evaluated in any order.

Now, b++ has the meaning of "increment b , but evaluate to its previous value". So b++ may cause the increment to happen prior to the assignment taking place, yes, but the value of (b++) is the address before the increment happened. And that is why b is updated to point at the next element, while modifying the current one, in one expression.

• Oh, I see. *(b++) is actually evaluated before assignment operator, but because post-increment is basically a function that return value before increment (in this case, &a[0]), so the result is seemed as if post-increment is done after assignment. Then, wouldn't that means post-increment operator requires extra memory (to store the returned original value)? –  pbeta Commented Mar 10, 2019 at 10:15
• @pbeta - Maybe, maybe not. For the case in your question, a compiler is allowed to actually do the increment after the assignment. The reason is that the observable behavior of your program remains the same, and so under the as-if rule, such an optimization is possible. If it was an overloaded operator, it would probably incur a bit more space. But either way, it's not something I'd fret over if I really needed a post increment. –  StoryTeller - Unslander Monica Commented Mar 10, 2019 at 10:18

Post increment ( b++ ) increments b , then returns the previous value of b .

Pre increment ( ++b ) increments b , then returns the new value of b .

To get the behavior you're expecting, change from post-increment to pre-increment.

For example:

Yields the following output:

Table is Correct. And there is no confusion for the result. Just remember the fact that post increment(PI) or decrement(DI), perform +1 or -1 update after the current statement containing PI or DI.

* (b++) = 5;

1st b++ will take place first as it is in parentheses. but b didn't move next yet. As compiler always remember in post operations that it would perform it after the current statement. so it is like:

*b = 5; // a[0]=5; compiler remembered b=b+1; to be executed.

so now b = b+1;

hence b is now pointing at a[1];

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged c++ operator-precedence or ask your own question .

• The Overflow Blog
• Mobile Observability: monitoring performance through cracked screens, old...
• At scale, anything that could fail definitely will
• Featured on Meta
• Announcing a change to the data-dump process
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Feedback requested: How do you use tag hover descriptions for curating and do...
• Staging Ground Reviewer Motivation

Hot Network Questions

• Sum of reciprocals of rough numbers
• Is loss of availability automatically a security incident?
• Why is the stall speed of an aircraft a specific speed?
• Can it be acceptable to take over CTRL + F shortcut in web app
• Velocity dispersion of stars in galaxies
• Why do height-by-age graphs start at 5, not 0?
• What happens to entropy during compression?
• When a star becomes a black hole do the neutrons that are squeezed together release binding energy and if so does this energy escape from the hole?
• Should you refactor when there are no tests?
• How did Dwight Dixon acquire Charles Charles' watch?
• Could there be a runaway thermonuclear fusion in ocean of heavy water?
• Correctly modelling a continuous log dose-response relationship in meta-regression for small dosages
• Invest smaller lump sum vs investing (larger) monthly amount
• Driveway electric run using existing service poles
• Boost Converter Efficiency Input Current
• What is the translation of a code monkey in French?
• Is exclusivity optimal from a utilitarian perspective? What's wrong with being non-exclusive?
• new versions of fancyhdr break caesar_book class
• Can a British judge convict and sentence someone for contempt in their own court on the spot?
• Expensive constructors. Should they exist? Should they be replaced?
• When you use the subjunctive tense for events that have happened?
• Word for a collection of awards, such as an Olympic athlete’s earned medals
• In Lord Rosse's 1845 drawing of M51, was the galaxy depicted in white or black?
• Light switch that is flush or recessed (next to fridge door)