CPE 112 Lecture 18 - Unary Operators

Summary

This video tutorial explains unary operators in programming, focusing on operators that require only one operand. It covers the sign operator, decrement, and increment operators, detailing their functionality with examples. The video distinguishes between pre and post-increment/decrement operators and illustrates their behavior in assignment statements. Additionally, the script explores the 'sizeof' operator, which returns the size of its operand in bytes. The tutorial provides clear examples of how each operator works, making it easy to understand their effects on variables and expressions.

Takeaways

• 😀 Unary operators require only one operand to operate.
• 😀 The sign operator changes the sign of a number: positive to negative, or vice versa.
• 😀 The decrement operator (x--) reduces the operand by 1, while the increment operator (x++) increases it by 1.
• 😀 Pre and post operators affect the order in which operations are performed: pre (e.g., --x, ++x) happens before the operand is used, and post (e.g., x--, x++) happens after.
• 😀 The post decrement and pre decrement operators have the same effect when used alone, as do post and pre increment operators.
• 😀 Post decrement or increment happens last in an expression, while pre decrement or increment happens first.
• 😀 In a statement like `y = x--`, the assignment happens first, and the decrement occurs afterward.
• 😀 In a statement like `y = --x`, the decrement happens first, and then the assignment occurs.
• 😀 The `sizeof` operator returns the size of a data type or expression in bytes, useful for understanding memory allocation.
• 😀 Common data types and their sizes: `char` is 1 byte, `int` is 2 bytes, `float` is 4 bytes, and `double` is 8 bytes.

Q & A

What are unary operators and how do they differ from other types of operators?

Unary operators are operators that require only one operand to function, unlike binary operators that need two operands. Examples include the sign operator, increment, and decrement operators.

What does the sign operator do and how does it work?

The sign operator changes the sign of its operand. If the operand is positive, it becomes negative, and if the operand is negative, it becomes positive. For example, if x is 5, using the sign operator will set y to -5.

What is the difference between pre-decrement and post-decrement operators?

In pre-decrement, the operand is decremented first, before being used in an expression. In post-decrement, the operand is used first in the expression and then decremented. The outcome is the same if the operator is the only one in the statement.

How do pre-increment and post-increment operators function?

Both pre-increment and post-increment operators add 1 to the operand. The difference is that in pre-increment, the operand is incremented before being used, while in post-increment, the operand is used first and then incremented.

What is the effect of using pre-decrement or post-decrement in a statement with multiple operators?

When there are multiple operators in a statement, the order of execution depends on whether the operator is pre or post. For example, in 'y = x--', the assignment happens before the decrement because the post-decrement operator is used.

Why does the output of 'y = x--' display y as 5 while x becomes 4?

In 'y = x--', the value of x is assigned to y before the decrement occurs, so y gets the original value of x (which is 5). After the assignment, x is decremented, resulting in x becoming 4.

How does pre-increment work in a statement with multiple operators, like 'y = ++x'?

In the case of pre-increment, the increment happens before the assignment. So, in 'y = ++x', x is incremented first, then the new value of x is assigned to y.

How does the 'sizeof' operator work in C, and what type does it return?

The 'sizeof' operator returns the size of its operand in bytes. The result is of integer type, as it provides the number of bytes used to store the operand. For example, 'sizeof(int)' returns 2 bytes, as integers are typically allocated 2 bytes in memory.

What is the size of different data types, such as char, int, float, and double?

In typical systems, the size of data types are as follows: char is 1 byte, int is 2 bytes, float is 4 bytes, and double is 8 bytes. These sizes can vary depending on the system architecture.

Why does the output of 'sizeof(char)' return 1 even when the character's value is assigned?

The 'sizeof' operator returns the size of the data type, not the value. Since 'char' is always 1 byte in memory, 'sizeof(char)' will return 1 regardless of the specific character value.