C++ Loops MCQ Quiz

The do-while loop checks its condition at the end of the loop, which guarantees that the loop body will execute at least once regardless of the condition.

The continue statement skips the rest of the loop body when i equals 2, so the number 2 is not printed. The loop runs for i values 0, 1, 3, and 4.

The break statement is used to terminate a loop immediately and transfer control to the statement following the loop.

The while loop checks the condition before executing the loop body. Since i is initialized to 10 and the condition is i < 10 (which is false), the loop body never executes.

This is a nested loop. The outer loop runs 3 times (i=0,1,2) and for each iteration of the outer loop, the inner loop runs 2 times (j=0,1). So the output shows all combinations of i and j values.

The for loop is specifically designed for situations where the number of iterations is known in advance, as it allows initialization, condition checking, and increment/decrement in a single line.

The range-based for loop requires the container to have begin() and end() methods that return iterators, or for the container to be an array.

The post-decrement operator returns the original value before decrementing. So when x is 5, the condition evaluates to true (5), then x becomes 4 which is printed. This continues until x becomes 0, the condition evaluates to false (0), and the loop stops.

The for(;;) loop is a common way to create an infinite loop in C++ as it has no initialization, condition, or increment expressions, so it will run forever.

The continue statement skips the remaining code in the current iteration of a loop and proceeds to the next iteration.

The loop breaks when i equals 3, so the value of i after the loop is 3. Note that the increment (i++) doesn't execute after the break.

All these techniques can improve loop performance: Loop unrolling reduces loop overhead, loop inversion changes while to do-while to reduce jumps, and loop fusion combines multiple loops into one to improve cache performance.

The total number of iterations is n multiplied by log(n), so the time complexity is O(n log n), which is common in efficient sorting algorithms like merge sort and heap sort.

Structured bindings, introduced in C++17, allow unpacking tuple-like objects directly in range-based for loops, making the code more readable and efficient.

Since i is unsigned, when it reaches 0 and then decrements, it wraps around to the maximum value for unsigned int, causing an infinite loop.

All these STL algorithms can replace explicit loops: std::transform for mapping, std::accumulate for reduction, and std::for_each for applying a function to each element, often resulting in cleaner and more optimized code.

The Ranges library introduced in C++20 provides a new way to work with sequences of elements, including range-based algorithms and views that can be composed, often eliminating the need for explicit loops.

Loops without loop-carried dependencies (where iterations don't depend on previous iterations) are easiest to parallelize safely, as there's no need for synchronization between iterations.

The inner loop runs j from 0 to i-1 for each value of i. So for i=1: 1 iteration, i=2: 2 iterations, i=3: 3 iterations, i=4: 4 iterations. Total = 0+1+2+3+4 = 10.

All these techniques can help with branch prediction: Loop tiling improves cache locality, loop unswitching moves conditionals outside loops, and loop peeling handles initial iterations separately to make remaining iterations more predictable.