C++ Programming Basic Syntax Syllabus

List the six relational (comparison) operators in C++ and the type of value they produce.

They are `==` (equal), `!=` (not equal), `<` (less than), `>` (greater than), `<=` (less than or equal), and `>=` (greater than or equal). Each yields a `bool` (`true`/`false`).

What is a common bug caused by confusing `=` and `==` in a condition?

`=` is assignment while `==` is equality comparison. Writing `if (x = 5)` assigns $5$ to `x` and evaluates to `true` (nonzero), instead of testing whether `x` equals $5$ as `if (x == 5)` intends.

List the three logical operators in C++ and the meaning of each.

`&&` is logical AND (true only if both operands are true), `||` is logical OR (true if at least one is true), and `!` is logical NOT (inverts the truth value).

What is short-circuit evaluation of `&&` and `||` in C++?

For `A && B`, if `A` is false, `B` is not evaluated (result is already false). For `A || B`, if `A` is true, `B` is not evaluated. This avoids unnecessary computation and enables guard patterns like `p && p->x`.

List the six bitwise operators in C++.

They are: AND `&`, OR `|`, XOR `^`, NOT (one's complement) `~`, left shift `<<`, and right shift `>>`.

What does the bitwise XOR operator `^` produce, and what is $5 \char`\^ 3$ in binary?

XOR yields $1$ in each bit position where the two operands differ. $5 = 101_2$ and $3 = 011_2$, so $5 \oplus 3 = 110_2 = 6$.

What is the arithmetic effect of the left shift `x << n` on a non-negative integer?

Left-shifting by $n$ bits multiplies the value by $2^{n}$ (assuming no overflow). For example, $3 << 2 = 3 \times 2^{2} = 12$.

What is the arithmetic effect of the right shift `x >> n` on a non-negative integer?

Right-shifting by $n$ bits performs integer division by $2^{n}$, discarding the low bits. For example, $20 >> 2 = \lfloor 20 / 2^{2} \rfloor = 5$.

What does the bitwise NOT operator `~` do, and what is `~5` for a signed 8-bit representation?

`~` flips every bit (one's complement). For a signed value, $\texttt{\char`\~}x = -x - 1$, so `~5` $= -6$.

What is the difference between bitwise AND `&` and logical AND `&&`?

`&` operates bit-by-bit on the binary representations of its operands (e.g. $6 \,\&\, 3 = 2$), while `&&` treats operands as booleans and returns a single `true`/`false` with short-circuiting.

What is the simple assignment operator, and name three compound assignment operators.

The simple assignment is `=`. Compound assignments combine an operation with assignment, e.g. `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=`. For example `x += 3` means `x = x + 3`.

What does the compound assignment `x <<= 2` do?

It left-shifts `x` by 2 bits and stores the result back in `x`, equivalent to `x = x << 2`, i.e. multiplying `x` by $2^{2} = 4$.

What is the associativity of the assignment operator `=` in C++, and what does `a = b = c` do?

Assignment is right-associative, so `a = b = c` is evaluated as `a = (b = c)`: `c` is assigned to `b`, and that result is then assigned to `a`.

What does the `sizeof` operator return, and is it evaluated at compile time or run time?

`sizeof` returns the size in bytes of a type or object as a `size_t`. It is a compile-time operator (its operand is not evaluated), e.g. `sizeof(int)` is typically $4$.

Describe the ternary conditional operator `?:` and its general syntax.

It is the only ternary operator in C++: `condition ? expr1 : expr2`. If `condition` is true it evaluates to `expr1`, otherwise to `expr2`. Example: `int max = (a > b) ? a : b;`.

What do the address-of `&` and dereference `*` operators do when used as unary operators?

Unary `&x` yields the memory address (a pointer) of `x`; unary `*p` dereferences a pointer `p` to access the object it points to. They are inverse operations.

What is the purpose of the scope resolution operator `::` in C++?

`::` accesses a name within a specific scope: a namespace member (`std::cout`), a class's static/member definition (`Class::member`), or the global scope (`::x` when a local hides it).

What is the general syntax and behavior of an `if-else` statement?

Syntax: `if (condition) { /*A*/ } else { /*B*/ }`. If `condition` evaluates to `true`, block A runs; otherwise block B runs. The `else` clause is optional.

How does an `else if` ladder work, and how many of its blocks execute?

An `else if` ladder chains conditions: `if(c1){} else if(c2){} else {}`. Conditions are tested top to bottom; the block of the first true condition runs and the rest are skipped, so at most one block executes.

In C++, which rule resolves the 'dangling else' ambiguity?

An `else` always binds to the nearest preceding unmatched `if` within the same block. Braces `{}` should be used to force a different association.

What is the required syntax of a `switch` statement in C++?

`switch(expr){ case const1: statements; break; case const2: statements; break; default: statements; }`. The `expr` must be an integral or enum type, and each `case` label must be a compile-time constant.

What is 'fall-through' in a C++ `switch` statement?

If a `case` block lacks a `break`, execution continues into the next `case`'s statements (fall-through). This is sometimes intentional for grouping cases but is a common source of bugs when accidental.

What is the role of the `default` label in a `switch`, and is it required?

`default` runs when no `case` label matches the switch expression. It is optional; if omitted and no case matches, the `switch` does nothing. It need not be placed last.

Why can't a `switch` statement branch on a `float`, `double`, or `string` in C++?

A `switch` requires an integral or enumeration expression and case labels that are integral constant expressions. Floating-point and `std::string` values are not integral constant expressions, so they are disallowed.

What are the four parts of a C++ `for` loop and their execution order?

Syntax: `for(init; condition; update) { body }`. Order: `init` runs once; then `condition` is tested — if true, `body` runs, then `update` runs, and the condition is re-tested; the loop ends when `condition` is false.

How does a `while` loop differ from a `do-while` loop in C++?

A `while` loop tests its condition before the body, so the body may run zero times. A `do-while` loop tests the condition after the body, guaranteeing the body runs at least once.

What is the required syntax of a `do-while` loop, including punctuation?

`do { body } while (condition);` — note the trailing semicolon after the `while(condition)`, which is mandatory and distinguishes it syntactically from a plain `while` loop.

What is the difference between the `break` and `continue` statements inside loops?

`break` immediately terminates the entire loop and transfers control after it. `continue` skips the rest of the current iteration and jumps to the loop's next condition test (and update step, in a `for` loop).

What is a range-based `for` loop in C++11, and give its syntax.

It iterates directly over elements of a container/array: `for (auto element : container) { ... }`. Using `auto&` binds by reference to allow modification and avoid copies.

How do you write an intentional infinite loop in C++ using `for` and using `while`?

Using `for`: `for(;;) { ... }` (all three parts omitted). Using `while`: `while(true) { ... }`. Both loop forever until an internal `break`, `return`, or exception exits them.