Knowledge Test Score Board
— · 0%
Work through the questions below — your score updates as you go.
Keep going · grade bands mapped to DCU's honours scale
Only your first attempt at each question counts toward this score. Reload the page to reset.
This section contains 25 interactive knowledge checks designed to test your understanding of the materials covered in Chapter 3. The questions span C++ history, fundamental types, pointers, control flow, string manipulation, bitwise operations, and exception handling.
Please remember that many of the quizzes have multiple correct answers , and you must select all applicable options to succeed. I have carefully balanced the lengths of the answers, so take your time to evaluate each option thoroughly.
Good luck!
Derek.
Which of the following statements accurately describe the evolution and standardisation of the C++ programming language? derekmolloy.ie
Modern standardisation efforts, such as C++11, C++14, and C++23, continuously update the language to introduce safer and more efficient features.
C++ was developed by Bjarne Stroustrup as 'C with Classes' to integrate object-oriented features with the low-level memory efficiency of C.
The C++ language is purely object-oriented, meaning that procedural programming styles (like standard C functions) are strictly prohibited.
The ISO committee enforces strict backward compatibility, meaning code written for older compilers is guaranteed to compile flawlessly on modern ones. Submit Answer
Complete the Modern C++ Constants and Types derekmolloy.ie Drag snippets from the pool into the blanks so the program produces the output shown, then click Submit.
1 #include < ····· >
2
3 // Platform-independent 8-bit unsigned integer
4 ····· hardware_register = 0xFF;
5
6 // Inform the compiler this value might change externally
7 ····· int sensor_reading = 0;
Available Snippets
iostream
uint8_t
stdint
cstdint
unsigned char
static
const
volatile
Submit
1 // Ensure a constant is evaluated at compile time
2 // select an option below
const int MAX_BUFFER_SIZE = 1024;
constexpr int MAX_BUFFER_SIZE = 1024;
volatile int MAX_BUFFER_SIZE = 1024;
static int MAX_BUFFER_SIZE = 1024;
When configuring a C++ compiler like GCC for an embedded project, how do the optimisation flags (e.g., -O0, -O3, -Os) affect the resulting code? derekmolloy.ie
The '-O3' flag aggressively applies inlining and loop unrolling to maximize execution speed, though it may increase the final compiled binary size.
The '-O0' flag entirely disables compiler optimisations, ensuring the generated machine code exactly matches the source code for straightforward debugging.
The '-Os' flag is specifically designed to reduce the physical size of the compiled machine code, making it ideal for flash-constrained microcontrollers.
The '-Ofast' flag strictly enforces all ANSI/ISO C++ standards to guarantee mathematical precision, automatically slowing down execution. Submit Answer
Predict the output of Type Conversion and Division derekmolloy.ie Read the code below, then choose the terminal output it produces and click Submit.
1 #include <iostream>
2
3 int main() {
4 int x = 7;
5 int y = 2;
6 float z = x / y;
7
8 std::cout << z << "\n";
9 std::cout << static_cast<float>(x) / y << "\n";
10 return 0;
11 }
Submit Answer
Concept Match
Match the Modern C++ Construct to its Benefit derekmolloy.ie Drag each definition into its matching concept slot, then click Submit. Tap × to return a placed card to the pool.
Definition Pool
A non-arithmetic type representing raw memory bits, preventing accidental numeric calculations.
A compiler attribute that issues a warning if the programmer ignores a function's returned value.
A scoped enumeration that prevents name collisions and provides strict type safety.
A modern, highly readable alternative to typedef that supports template aliasing (e.g., Name = Value).
Submit
Which of the following statements about C++ Pointers and Memory are correct? derekmolloy.ie
The 'nullptr' keyword (introduced in C++11) represents a type-safe null pointer and should always be preferred over the legacy 'NULL' macro.
The address-of operator (&) returns the specific physical or virtual memory location where a given variable is stored.
The dereference operator (*) retrieves the actual data value stored at the memory address currently held by the pointer.
A void* pointer can safely be dereferenced directly to access data, as the compiler automatically determines the correct underlying data type. Submit Answer
1 struct Sensor {
2 void initialize() {}
3 };
4
5 int main() {
6 Sensor* s = new Sensor();
7 // Access the initialize method via the pointer
8 // select an option below
9 delete s;
10 return 0;
11 }
Complete the Pointer Arithmetic Logic derekmolloy.ie Drag snippets from the pool into the blanks so the program produces the output shown, then click Submit.
1 int data[3] = {10, 20, 30};
2 int *ptr = &data[0];
3
4 // Increment the pointer to point to the next element
5 ptr ····· ;
6
7 // Dereference the pointer to retrieve the current value
8 int current_value = ····· ptr;
9
10 // Safely assign a null state when finished
11 ptr = ····· ;
Submit
Predict the output: Pointer Precedence derekmolloy.ie Read the code below, then choose the terminal output it produces and click Submit.
1 #include <iostream>
2
3 int main() {
4 int arr[] = {5, 10, 15};
5 int *p = arr;
6
7 std::cout << *p++ << " ";
8 std::cout << (*p)++ << " ";
9 std::cout << *p;
10
11 return 0;
12 }
Submit Answer
Why is 'Pass by Const Reference' (e.g., void process(const std::string& data)) considered a modern C++ best practice for large objects? derekmolloy.ie
It allows the function to freely modify the original object in memory, bypassing any encapsulation restrictions applied by the class.
It automatically converts the object into a C-style char array before passing it into the function block.
It passes a lightweight reference rather than creating a full memory copy of the object, significantly improving runtime efficiency.
The 'const' qualifier strictly guarantees that the function cannot accidentally alter the original data, ensuring program safety. Submit Answer
Concept Match
Match the Memory or Scope Concept derekmolloy.ie Drag each definition into its matching concept slot, then click Submit. Tap × to return a placed card to the pool.
Definition Pool
The designated area within a program (often defined by curly braces {}) where a variable is active and accessible.
A complete copy of the variable is sent to the function; changes do not affect the original data.
A pointer that references a memory location that has already been deallocated or destroyed.
An alias to the original variable is passed, allowing the function to modify the source data directly.
Submit
Which of the following describes the differences between C-style strings (<cstring>) and modern C++ strings (<string>)? derekmolloy.ie
C-style strings are fundamental arrays of characters that must be manually terminated with a special null character ('\0').
The modern 'std::string_view' provides a highly efficient, read-only view of a string without triggering costly memory allocations.
Modern std::string objects automatically manage their own underlying memory and can be safely concatenated using the standard '+' operator.
The C standard library function 'strcmp()' is used to intuitively combine two C-style strings together without memory overflow risks. Submit Answer
Predict the output: Loops and Break/Continue derekmolloy.ie Read the code below, then choose the terminal output it produces and click Submit.
1 #include <iostream>
2
3 int main() {
4 for(int i = 1; i <= 5; ++i) {
5 if (i == 3) { continue; }
6 if (i == 5) { break; }
7 std::cout << i;
8 }
9 return 0;
10 }
Submit Answer
Efficient String Handling derekmolloy.ie 1 #include <iostream>
2 #include <string_view>
3
4 // Pass a read-only view of a string without copying
5 // select an option below
6 std::cout << "Status: " << message << std::endl;
7 }
void print_status(std::string_view message)
void print_status(std::string message)
void print_status(const char* message)
void print_status(std::string& message)
Modern Range-Based For Loop derekmolloy.ie Drag snippets from the pool into the blanks so the program produces the output shown, then click Submit.
1 #include <iostream>
2 #include <vector>
3
4 int main() {
5 std::vector<int> numbers = {10, 20, 30};
6
7 // Safely iterate through the vector without copying elements
8 for ( ····· auto ····· num : numbers) {
9 std::cout << num << " ";
10 }
11 return 0;
12 }
Submit
Based on the 'Robot Arena' Virtual Lab, why is introducing a mutable variable (like 'ammo') significantly different from pure control flow (like a 'while' loop)? derekmolloy.ie
It forces the programmer to read the variable's current value inside a conditional (e.g., if ammo == 0) to make real-time operational decisions.
Mutable variables automatically pause the execution of the CPU, giving the hardware time to synchronise with external moving targets.
It eliminates the need for any block scope braces in the source code, as the variable handles all logic branching automatically.
A mutable variable introduces persistent state, meaning the program must actively track and update a value that changes dynamically over time. Submit Answer
Concept Match
Match the String Function to its Behavior derekmolloy.ie Drag each definition into its matching concept slot, then click Submit. Tap × to return a placed card to the pool.
Definition Pool
A C-style function that appends one char array to another, which can cause buffer overflows if not careful.
A C++ function used with cin to read an entire line of text, including spaces and tabs.
A C-style function that calculates string length by counting bytes until it hits the null terminator.
Accesses a character in a C++ string safely by performing runtime bounds checking.
Submit
Why are bitwise operations considered essential for low-level embedded edge programming? derekmolloy.ie
They automatically translate human-readable string commands into secure, encrypted binary machine code payloads.
They allow multiple floating-point values to be securely compressed into a single 8-bit character array.
They provide an extremely fast, computationally efficient method to perform multiplication and division by powers of two using shift operators.
They allow developers to set, clear, or toggle specific individual bits within a hardware configuration register without disturbing adjacent bits. Submit Answer
Predict the output: Bitwise Shifting derekmolloy.ie Read the code below, then choose the terminal output it produces and click Submit.
1 #include <iostream>
2 #include <cstdint>
3
4 int main() {
5 uint8_t a = 5; // Binary: 00000101
6 uint8_t b = a << 2;
7 uint8_t c = b >> 1;
8
9 std::cout << (int)b << " " << (int)c;
10 return 0;
11 }
Submit Answer
1 uint8_t flags = 0b00000001;
2 // Use bitwise XOR to toggle the state of the first bit
3 // select an option below
Structure a C++ Exception Handler derekmolloy.ie Drag snippets from the pool into the blanks so the program produces the output shown, then click Submit.
1 #include <iostream>
2 #include <vector>
3 #include <stdexcept>
4
5 int main() {
6 std::vector<int> data = {1, 2, 3};
7 ····· {
8 int value = data.at(10); // Will throw out_of_range
9 }
10 ····· (const std:: ····· & e) {
11 std::cerr << "Error: " << e. ····· () << "\n";
12 }
13 return 0;
14 }
Available Snippets
fail
out_of_range
throw
error
catch
what
message
exception
try
Submit
Concept Match
Match the Operator or Exception Concept derekmolloy.ie Drag each definition into its matching concept slot, then click Submit. Tap × to return a placed card to the pool.
Definition Pool
A unary operator that inverts all the bits of a number, turning 1s to 0s and vice versa.
A keyword promising the compiler that a specific function will absolutely never throw an exception.
Compares two numbers bit-by-bit; the resulting bit is 1 only if the corresponding bits are different.
The process where the runtime system safely destroys local objects as it searches upward for an exception handler.
Submit
Catching Exceptions by Reference derekmolloy.ie 1 try {
2 risky_operation();
3 }
4 // Catch the standard exception by constant reference
5 // select an option below
6 std::cerr << "Caught standard exception";
7 }
catch (const std::exception& e)
Regarding operator precedence in C++, why is it heavily recommended to wrap bitwise operations in parentheses when evaluating conditions? derekmolloy.ie
Because bitwise operators (like &, |) often have a lower precedence than equality operators (like ==), leading to unintended evaluation order.
Because relying on obscure precedence rules makes code incredibly difficult for other developers to read and maintain.
Because parentheses physically instruct the CPU's arithmetic logic unit (ALU) to cache the values in faster SRAM.
Because the compiler will immediately crash and refuse to compile any bitwise logic that lacks enclosing parentheses. Submit Answer
Congratulations on completing the Chapter 3 Knowledge Test!
Review any questions you missed to ensure a solid foundation in the “C of C++” before moving on to the advanced Object-Oriented implementations in Chapter 5.
