Free CPA-21-02 sample questions

Correct answer: The allocated memory block may not be correctly aligned for storing objects of type `T`, leading to undefined behavior or performance degradation.

The core issue is memory alignment. `new char[POOL_SIZE]` returns a pointer that is guaranteed to be aligned for `char`, but not necessarily for any arbitrary type `T`. If `T` has stricter alignment requirements (e.g., `double` or a struct with specific members), placing it at an unaligned address `pool + offset` invokes undefined behavior. A robust memory pool must account for `alignof(T)` when calculating offsets.

Correct answer: ```cpp enum class LogLevel { INFO, WARN, ERROR }; void setLogLevel(LogLevel level); setLogLevel(LogLevel::INFO); // Compiles setLogLevel(0); // Fails ```

The `enum class` (scoped enumeration) is specifically designed to provide strong type safety. It prevents implicit conversions to and from integer types. Programmers must explicitly cast if a conversion is needed. The call `setLogLevel(0)` will fail to compile because `0` is an `int` and cannot be implicitly converted to the `LogLevel` type.

Correct answer: If `parseData` throws an exception, the `delete file;` statement at the end of the function will not be executed, causing a memory leak.

This code violates the RAII (Resource Acquisition Is Initialization) principle. If `parseData(*file)` throws an exception, the function's execution stack is unwound, and control transfers to the nearest `catch` block. The final `delete file;` line is skipped, resulting in a memory leak. The correct approach is to manage the resource with an object whose destructor handles cleanup, such as creating the `std::ifstream` object on the stack or using a smart pointer like `std::unique_ptr`.

Correct answers: Declare the destructor in the `User` base class as `virtual`.; Delete the copy constructor and copy assignment operator in the `User` base class, or declare them as `protected`.

Correct answer: 9

The preprocessor performs a direct text substitution. The line `std::cout << SQUARE(a + 1);` expands to `std::cout << a + 1 * a + 1;`. Due to operator precedence, the multiplication `1 * a` is performed first. The expression evaluates as `4 + (1 * 4) + 1`, which is `4 + 4 + 1`, resulting in `9`. To fix this, the macro should be defined with parentheses: `#define SQUARE(x) ((x) * (x))`.

Correct answer: False

This statement is false. The presence of a user-defined destructor does not prevent the compiler from generating a default constructor. However, if a user declares *any* constructor (e.g., a copy constructor or a constructor with parameters), the compiler will then refrain from generating the default constructor.

Correct answer: Add a virtual destructor to the `GameObject` base class: `virtual ~GameObject() = default;`.

The most critical issue is the lack of a virtual destructor in the polymorphic base class `GameObject`. When `delete` is called on a base class pointer (`GameObject*`), if the destructor is not virtual, only the base class destructor is invoked. This leads to undefined behavior because the derived class's destructor (e.g., `~Enemy()`) is never called, and resources owned by the derived class are not released. This is a classic cause of memory corruption and leaks in C++. Declaring the base class destructor as `virtual` ensures that the entire object hierarchy is destroyed correctly.

Correct answer: 18

The bitwise AND operation (`&`) compares the bits of two numbers. A bit in the result is set to 1 only if the corresponding bits in both operands are 1. `flags` (0b10110) `mask` (0b11010) ----------------- `result`(0b10010) The binary value `0b10010` is calculated as (1 * 16) + (0 * 8) + (0 * 4) + (1 * 2) + (0 * 1), which equals 16 + 2 = 18.

Correct answer: `void doubleValues(int* arr, size_t size);`

In C++, when an array is passed to a function, it decays into a pointer to its first element. To modify the original array's contents, the function must accept a pointer to the element type. `int* arr` is the idiomatic way to declare a parameter that accepts an array of integers. The function can then use pointer arithmetic or array subscripting to access and modify the elements. A `void` return type is appropriate as the modifications are done in-place.

Correct answer: 5

The expression is evaluated as follows: 1. The outer condition `(y > 3)` is checked. Since `y` is 5, this is true. 2. The true-branch of the outer ternary is evaluated: `( (y < 10) ? y++ : y-- )`. 3. The inner condition `(y < 10)` is checked. Since `y` is 5, this is true. 4. The true-branch of the inner ternary is evaluated: `y++`. 5. The post-increment operator `y++` returns the *current* value of `y` (which is 5) and then increments `y` to 6. 6. The value 5 is assigned to `x`.