Precedence and Associativity of Operators

Summary

This lecture delves into the critical concepts of operator precedence and associativity in programming. It explains how precedence determines the order of evaluation when multiple operators are present, using examples like multiplication vs. addition. The lecture then clarifies associativity, which comes into play when operators share the same precedence, and it decides the direction of evaluation (left-to-right or right-to-left). The instructor uses a table to illustrate various operators' precedence and associativity, emphasizing the importance of understanding these concepts for correct program behavior. The lecture concludes with a homework problem to test comprehension.

Takeaways

• 🔢 **Operator Precedence**: Determines the order in which operators in an expression are evaluated, with higher precedence operators being evaluated first.
• 🔄 **Multiplication vs. Addition**: Multiplication has higher precedence than addition, so it is evaluated first in expressions.
• 🔁 **Associativity**: Comes into play when operators have the same precedence, deciding whether operations are performed left-to-right or right-to-left.
• 🔄 **Division and Multiplication**: Both have the same precedence, so their order is determined by associativity, which is left-to-right for these operators.
• 📚 **Precedence Table**: A reference that lists operators by their level of precedence, from highest (at the top) to lowest (at the bottom).
• 👥 **Parentheses**: Have the highest precedence and are used to explicitly specify the order of operations in an expression.
• 🔄 **Postfix vs. Prefix**: Postfix increment/decrement operators have higher precedence than prefix ones, and their associativity is left-to-right, unlike prefix which is right-to-left.
• 🔄 **Associativity of Unary Operators**: Unary operators, like prefix and postfix, have right-to-left associativity, which is different from most other operators.
• ❗ **Undefined Behavior**: The order in which functions are called when there's only one operator (like assignment) is not defined and can vary by compiler.
• 📝 **Homework Problem**: A reminder that understanding precedence and associativity is crucial for predicting the behavior of complex expressions in programming.

Q & A

What is the precedence of operators and how does it affect expression evaluation?

Operator precedence determines the order in which operators in an expression are evaluated when multiple operators are present. An operator with higher precedence is evaluated before an operator with lower precedence.

Can you provide an example to illustrate the concept of operator precedence?

Yes, in the expression 5 + 3 * 2, the multiplication operator (*) has higher precedence than the addition operator (+), so 3 * 2 is evaluated first resulting in 6, and then 5 + 6 equals 11.

What is the associativity of operators?

Associativity of operators comes into play when the precedence of the operators is the same. It determines whether an expression involving operators of the same precedence is evaluated from left to right or right to left.

How does the associativity of division and multiplication affect the evaluation of an expression?

Division and multiplication have the same precedence, so the associativity determines the order of evaluation. If associativity is left to right, division is performed first followed by multiplication.

What is the significance of parentheses in an expression?

Parentheses have the highest precedence among all operators and are used to explicitly specify the order of operations in an expression, overriding the default precedence and associativity rules.

Why are member access operators mentioned in the script, and what is their role?

Member access operators are used to access members of structures and are mentioned to highlight their precedence, which is higher than that of the assignment operator.

What is the difference between postfix and prefix increment/decrement operators in terms of precedence and associativity?

Postfix increment/decrement operators have higher precedence than prefix increment/decrement operators. Also, the associativity of postfix operators is from left to right, whereas for prefix operators it is from right to left.

How does the precedence and associativity of operators affect the evaluation of a program?

The precedence and associativity of operators dictate the order in which expressions are evaluated, which can significantly affect the outcome of a program. Understanding these concepts is crucial for predicting and controlling program behavior.

What is the associativity of the assignment operator, and why is it important?

The associativity of the assignment operator is from right to left, which is important for understanding how compound assignments are evaluated in expressions.

What does it mean when the script says that the behavior of calling functions in an expression is undefined?

It means that if two functions are called in an expression separated by an operator with which they both associate, the order in which the functions are called is not specified by the language standard, and can vary between different compilers or even different runs with the same compiler.

How can understanding precedence and associativity help in writing clearer code?

Understanding precedence and associativity helps in writing clearer code by allowing developers to use parentheses effectively to avoid ambiguity and to ensure that expressions are evaluated in the intended order.

Outlines

00:00

🔢 Understanding Operator Precedence and Associativity

This paragraph introduces the concepts of operator precedence and associativity in programming. Operator precedence determines the order in which operators are evaluated in an expression when multiple operators are present. For instance, multiplication has higher precedence than addition, meaning it is evaluated first. Associativity comes into play when operators have the same precedence, dictating whether operations are performed from left to right or right to left. The paragraph uses examples to illustrate these concepts, emphasizing their importance in programming.

05:00

📚 Precedence and Associativity of Various Operators

This section delves into the precedence and associativity of different operators, starting with the highest precedence operators such as parentheses and moving down to lower precedence operators like the comma operator. It explains how parentheses are used to clarify that an operand is a function rather than a variable, due to their high precedence over the assignment operator. The paragraph also touches on member access operators, postfix increment/decrement operators, and their precedence relative to prefix counterparts. The discussion highlights the significance of understanding these concepts to determine the order of evaluation in expressions.

10:02

🔄 Associativity and Undefined Behavior in Expressions

The paragraph discusses the importance of associativity when operators have the same precedence and how it can affect the order of evaluation. It clarifies that associativity only applies when there are two or more operators of the same precedence. The text also addresses the concept of undefined behavior in programming, where the order in which functions are called in an expression is not specified by the language, leading to potentially different outcomes depending on the compiler. This underscores the need for programmers to be aware of how their code may be interpreted by different compilers.

15:02

📝 Homework Problem on Operator Precedence and Associativity

In the final paragraph, a homework problem is presented to the audience, challenging them to apply their understanding of operator precedence and associativity to predict the output of a given C program fragment. The paragraph summarizes the lecture's key points and invites viewers to engage with the material by sharing their answers in the comments section. The problem is designed to reinforce the concepts discussed throughout the lecture and to encourage active learning and discussion among viewers.

Keywords

💡Precedence

Precedence refers to the priority of operators in an expression, determining which operations are performed first when multiple operators are present. It is crucial for understanding how expressions are evaluated in programming languages. In the script, the example given is an expression with both a multiplication and an addition operator. The precedence rule states that multiplication, having a higher precedence, is evaluated before addition, leading to the correct result of 17.

💡Associativity

Associativity defines the order in which operations of the same precedence level are performed. It comes into play when the operators in an expression have the same level of precedence. The script explains that if operators like multiplication and division have the same precedence, associativity (left-to-right or right-to-left) determines the evaluation order. The example used is 10 divided by 2 times 5, which equals 25 if evaluated left-to-right, but equals 1 if evaluated right-to-left.

💡Expression

An expression in programming is a combination of values, variables, operators, and functions that computes to a single value. The script discusses how expressions are evaluated based on the precedence and associativity of the operators they contain. Understanding expressions is fundamental to writing and interpreting code that performs calculations.

💡Operator

An operator is a symbol that tells the compiler to perform specific mathematical or logical operations. The script covers various types of operators, such as arithmetic, bitwise, and assignment operators, and how their precedence and associativity affect the evaluation of expressions.

💡Parenthesis

Parenthesis are used to explicitly specify the order of operations within an expression by increasing the precedence of the operations inside them. The script mentions that parenthesis have the highest precedence and are used to force the evaluation of the enclosed expression before others, such as in function calls.

💡Member Access Operators

Member access operators are used to access members (like variables and functions) of structures or objects. The script notes that these operators have a higher precedence than the assignment operator, which is important when accessing members for assignment or function calls.

💡Postfix Increment/Decrement

Postfix increment/decrement operators are used to increase or decrease a variable's value by one, after the variable's value has been used in an expression. The script points out that postfix increment/decrement operators have a higher precedence than their prefix counterparts, which is important when these operators are used in complex expressions.

💡Logical NOT

The logical NOT operator is a unary operator that inverts the truth value of a boolean expression. The script includes this operator in the precedence table, indicating its high precedence level, which is important for understanding how boolean expressions are evaluated.

💡Conditional Operator

The conditional operator is a ternary operator that selects one of two values depending on the evaluation of a boolean expression. The script highlights that the conditional operator has right-to-left associativity, which is unique compared to most other operators.

💡Assignment Operator

The assignment operator is used to assign values to variables. The script explains that the assignment operator has lower precedence than many other operators, which is why expressions enclosed in parentheses are evaluated before assignments in statements like 'int var = fun();'

💡Comma Operator

The comma operator is used to separate multiple expressions where the entire expression evaluates to the value of the last sub-expression. The script mentions that the comma operator has left-to-right associativity and is often used in for-loops for multiple discrete operations.

Highlights

Precedence of operators determines the order of evaluation in an expression.

Operators with higher precedence are evaluated first.

Multiplication has higher precedence than addition.

Associativity comes into play when operators have the same precedence.

Associativity can be either left to right or right to left.

Division and multiplication have the same precedence, and their associativity is left to right.

Parenthesis has higher precedence than the assignment operator.

Member access operators are used to access members of structures.

Postfix increment/decrement operators have higher precedence than prefix increment/decrement operators.

Associativity of postfix operators is from left to right, while prefix is from right to left.

Unary operators have associativity from right to left.

The order of evaluation for functions in an expression is not defined and is compiler-dependent.

Associativity only works when there are more than one operators of the same precedence.

Operators with the same precedence will have the same associativity.

The output of a program can be compiler-dependent when the order of function calls is not defined.

Understanding operator precedence and associativity is crucial for predictable program behavior.

Transcripts

In this lecture we are going to talk about

precedence and associativity of operators.

Precedence of operators come into picture

when in an expression we need to decide

which operator will be evaluated first.

Suppose, you have multiple operators in an expression.

Then which operators will be evaluated first

is decided by the precedence.

Operator with higher precedence will be evaluated first.

And this is so obvious.

Like for example, we have this expression

in which we have a plus operator

and we have a multiplication operator.

Maybe this particular operator will be evaluated first

and then it will produce the answer

as 17 because five into three is 15

and 15 plus two is 17.

Or maybe it is possible that this

particular operator will be evaluated first

and it will result the value 25.

Two plus three, which is equal to five.

Five into five is equal to 25.

Right? Now, which one is correct?

Precedence of multiplication is greater than the addition.

Please note down.

Precedence of multiplication is greater than the addition.

Therefore, this one is correct

and this one is not correct.

Because precedence of multiplication is greater,

therefore, three into five will be evaluated first

and then after that, addition would be performed.

Therefore, the final output is 17 and not 25. Okay.

Now, what is associativity of operators?

Associativity of operators come into picture

when precedence of operators are same.

Please note down.

When precedence of operators are same,

then only associativity comes into picture.

And we need to decide which operator will be evaluated first.

Of course, this whole thing will be done for the purpose

that which operator will be evaluated first.

Let's consider one example.

Here in this example, you will find out two operators

divide and multiply in a same expression.

The obvious question is,

which one will be evaluated first.

Associativity can be either left to right or right to left.

These are the only two possibilities.

If the associativity is left to right,

then division will be performed first

and then multiplication because we are going from left to right

and division will be performed first

and multiplication will be performed next.

Let me tell you one important point that,

division and multiplication both are having the same precedence.

Therefore, the associativity came into picture.

And here, we need to decide the order of evaluation

with the help of associativity and not by precedence.

If we are thinking about the associativity is going from left to right,

then division will be performed first

and then the multiplication .

Therefore, the final output is 25.

Because, 10 divided by two, is equal to five

and five into five is equal to 25.

If associativity is from right to left,

then multiplication will be performed first and then division.

Two into five is 10 and 10 divided by 10 equals to one.

Right? Now, which one is correct?

Let me tell you one thing.

Division will be performed first and then multiplication.

Because, these two operators are having the same precedence

and their associativity is actually from left to right.

And not from right to left.

Therefore, this one is correct

And this one is not correct. Okay.

Now, let's consider the precedence and associativity table.

In this particular table you will find out

different kinds of operators mentioned.

Apart from that, their associativities are also mentioned.

The topmost set of operators are

having the highest precedence among all the operators.

And the bottom most is having the least precedence.

First of all, we are going to talk about these operators.

These are parenthesis, these are brackets.

Then we have some member access operators.

And then we have postfix increment and decrement operators.

Let's talk about all these operators one by one.

Parenthesis is used in function calls, right?

Suppose, for example, we have a variable

and to this variable we are trying to assign

the value returned by this function.

But, my question is

how compiler would be able to know

that this particular operand is a function

and not a variable.

It can be a variable as well.

Why it is a function and not a variable?

Assignment operator is also fighting for this operand

that this particular operand belongs to me.

And these parenthesis also are fighting for this particular operand

that this particular operand belongs to me.

Now, who wins the battle?

Assignment operator is having less precedence as compared to parenthesis.

Please note down.

It is having less precedence.

Therefore parenthesis belongs to fun

and fun will be treated as a function.

Therefore, we can say that after precedence, it looks like this.

int var equal to fun()

This fun is an operand.

Of course, but it is a function and not a variable.

Because parenthesis is having greater precedence than assignment operator.

Therefore, this will be evaluated first

and then, the assignment is being performed.

I use parentheses to make this point clear

that this particular operand is not a variable, it is a function.

And because of the precedence,

of this particular operator is greater than the assignment operator.

Therefore, this operand belongs to this particular operator

and not this operator.

Suppose if assignment operator is having greater precedence than

fun will belong to assignment operator

and therefore it will be treated as a variable and not a function.

Then in that case, this particular statement looks like this.

Because, assignment operator is having greater precedence,

therefore, it will be evaluated first

and then after the parentheses will get evaluated.

Therefore, this fun is treated as a variable and not a function.

That is why precedence and associativity is important.

Because, we need to know what would be the order of evaluation.

Now, let's try to understand member access operators.

These two are member access operators.

They are used to access members of structures.

Please note down this point.

We will talk about structures later in this course.

Therefore, there is no point in

concentrating on these operators right now.

Then we have postfix increment and decrement operators.

Plus plus and minus minus.

If you remember that immediately after these member access operators,

we have postfix increment and decrement operators.

One important point that we need to know

related to these postfix increment and decrement operators is that,

Precedence of postfix increment or decrement operator

is greater than prefix increment or decrement operator.

You will find out in the precedence table

that prefix increment or decrement operator

will immediately appear after

postfix increment/decrement operator.

Therefore, postfix increment or decrement operator is having

greater precedence than prefix increment or decrement operator.

Apart from that,

Associativity of postfix is also different from prefix.

This is also very important point.

Associativity of postfix operators

is from left to right and that of prefix operators is from right to left.

Here, in this table, these are the postfix operators

and these are the prefix operators.

Because they appear first in the table,

Therefore, they are having the greater precedence

and this one is having the less precedence.

Apart from that,

associativity of postfix operators is from left to right.

And associativity of prefix operators is from right to left.

Okay.

Apart for that, then we have logical not operator

which we are well aware off.

Then we have bitwise negation operator.

Then of course, prefix increment or decrement operators.

Then we have unary plus and unary minus operator.

These operators might confuse you.

They are unary operators and not binary operators.

We can say that their signs, like plus 34, minus 36, like that.

Start and ampersand as already told you,

that we are going to cover these operators in pointers.

This particular operator is used for typecasting,

which we will discuss later on.

And sizeof operator, we already discussed a lot.

Apart from that,

we have multiplicative operators list

which consists of multiplication, division, and modulus.

All of them are having precedence from left to right.

Apart from that, we are having additive operators, like plus and minus.

They are also having associativity from left to right.

Then we have bitwise operators, relational operators,

equality operators, bitwise AND, bitwise XOR,

bitwise OR, bitwise AND, logical OR.

Then we have a conditional operator.

Associativity for conditional operator is right to left.

If you find out, many conditional operators in an expression,

then associativity for those conditional operators would be

from right to left and not from left to right.

Please remember this point.

Apart from that, we have assignment operators

and we already know one important point

about assignment operators.

That is their associativity is from right to left.

Then final operator in this list of

precedence and associativity of operators is comma operator.

Associativity for comma operator is from left to right.

Now the one most important point we need to know

is that condition and assignment operators

are having associativity from right to left and not from left to right.

Apart from that,

unary operators are also having associativity from right to left.

And all the rest of the operators are having

associativity from left to right.

Let's discuss some important facts related to these operators.

First of all,

Associativity can only help if there are

two or more operators of same precedence

and not when there is just one operator.

This is very important point.

Associativity can only help you

if there are at least two operators of same precedence

and not when there is just one operator.

In this particular example,

we can easily see that we are calling

two functions, fun one and fun two.

And whatever the value they will return,

finally, we add them using this addition operator.

And the result of this addition will get stored

inside this particular variable called a.

And then we simply print this variable. Right?

Here, in this function we are first trying to print Neso

and then we return value one at this place.

Here in this function, we are trying to print Academy

and then we return one to this particular place.

One plus one is equal to two

and the output of this printf function is two.

But my question is, which function will be called first?

Is it fun1 or is it fun2?

Most of us will give the answer as

fun1 will be called first and then fun2.

Because fun1 appears first in this expression.

But this is not correct.

So which function is called first?

Is it fun1 or is it fun2?

Now, let me give you the answer.

It is not defined whether fun1 will be called first

or whether fun2 will be called.

Behavior is undefined and output is compiled a dependent.

You cannot say that fun1 will be called first

and then after fun2 will be called.

Because fun1 appears first in this particular expression,

therefore, it would be called first and then after fun2 will be called.

It is not the case that always fun1 will be called first.

It might be the possibility that some compilers

will call fun2 first and then fun1.

It is simply not defined.

We cannot say anything about it.

First of all, there is no precedence issue here

because we just have one operator.

Here of course, between this addition operator and assignment operator

addition operator is having greater precedence.

Therefore, it will be evaluated first.

But my question is, which function will be called first?

The output is compiled a dependent.

Please note down, associativity will not

come into picture as we just have one operator.

And which function will be called first is undefined.

Associativity will only work when we have

more than one operators of same precedence.

Now, what is the output of this particular program?

Is it NesoAcademy2 or is it AcademyNeso2?

If fun1 will be called first,

then first Neso will be printed

and then after one is returned.

And then after fun2 will be called

and Academy will get printed

and it will return value one to this particular place.

One plus one is equal to two

which will get printed after printing NesoAcademy, right?

So, output can be NesoAcademy2.

But if fun2 to will be called first,

then the output would be AcademyNeso2, right?

So, what is the output?

We simply don't know.

Now, let's consider one more important fact.

Operators with same precedence have same associativity as well.

Here in this table, we can see that

these all operators are having same precedence. Right?

Although they are having the highest precedence

among all the other operators in this list,

but the operators, which are available

in this particular block are all having the same precedence.

And their associativity is also same, like left to right.

Suppose we find out this operator as well as this operator

within an expression, then of course

the associativity will be the same, left to right.

It doesn't make sense that this particular operator

is having left to right associativity

and this one is having right to left associativity.

Similarly, all these operators are having same precedence.

Therefore, their associativity would be also same,

that is from right to left.

And similarly, this concept is applicable to

all the other operators as well.

Now, let's consider one homework problem.

What is the output of the following C program fragment?

Is it true?

Or is it false?

You can always post your answers in the comments section below.

Okay friends, this is it for now.

Thank you for watching this lecture.