BudiBaduQuiziBadu

C++ Basics Quiz

C++
0 Passed
0% acceptance

40 in-depth questions covering C++ fundamentals, program structure, input/output operations, comments, compilation process, and exit codes — with 10 code examples to solidify understanding.

10 Questions
~20 minutes
1

Question 1

When developing a C++ application that needs to read user input from the console and display formatted output, which header file must be included to access the standard I/O streams?

A
iostream - provides cin, cout, and cerr objects for console input and output operations
B
stdio.h - legacy C-style I/O functions like printf and scanf
C
fstream - handles file-based input and output operations only
D
string - provides string manipulation but not console I/O capabilities
2

Question 2

In a C++ program that processes command-line arguments and returns different exit codes based on success or failure conditions, what is the correct signature for the main function?

A
int main(int argc, char* argv[]) - accepts argument count and array of C-style strings
B
void main() - no return value and no command-line argument support
C
int main() - returns integer but cannot access command-line arguments
D
string main(int args) - incorrect types for both return and parameters
3

Question 3

During the C++ compilation process, what happens when the preprocessor encounters an #include directive for a standard library header like <iostream>?

A
The preprocessor replaces the directive with the actual header file contents, making declarations available for compilation
B
The compiler immediately generates machine code for the included header functions
C
The linker searches for and connects the header file to the final executable
D
The preprocessor ignores standard headers and only processes user-defined includes
4

Question 4

When writing a C++ program that needs to handle both successful execution and error conditions, what are the conventional exit code values that should be returned from main?

A
Return 0 for success, non-zero values (typically 1-255) for different error conditions
B
Return 1 for success, 0 for any error to follow Unix conventions
C
Exit codes are optional and don't affect program behavior
D
Return -1 for success, positive values for errors in Windows systems
5

Question 5

In a cross-platform C++ application that must work on both Windows and Unix-like systems, what namespace qualification is typically used with standard library components?

A
std:: prefix for all standard library names to avoid naming conflicts and ensure portability
B
No namespace qualification needed as standard library names are global
C
using namespace std; directive to bring all standard names into global scope
D
Platform-specific namespaces like windows:: or unix:: for different systems
6

Question 6

Consider this C++ code that attempts to read an integer from console input and display it. What will happen when this program runs and the user enters '42' followed by Enter?

cpp
#include <iostream>

int main() {
    int number;
    std::cin >> number;
    std::cout << "You entered: " << number << std::endl;
    return 0;
}
A
Program successfully reads 42, stores it in number, and prints 'You entered: 42'
B
Compilation fails because iostream header is not included properly
C
Runtime error occurs because cin cannot read from console input
D
Program prints garbage value because number is uninitialized before reading
7

Question 7

When compiling a multi-file C++ project with separate header and implementation files, what is the typical sequence of commands using g++ compiler?

A
First compile implementation files to object files, then link them together: g++ -c file1.cpp file2.cpp && g++ file1.o file2.o -o program
B
Direct compilation in one step: g++ file1.cpp file2.cpp -o program
C
Compile headers first: g++ -c header1.h header2.h && g++ file1.cpp file2.cpp -o program
D
Link object files without compilation: g++ file1.o file2.o header1.h -o program
8

Question 8

In a C++ program that includes both single-line and multi-line comments, what happens to these comments during the compilation process?

A
Comments are completely removed by the preprocessor, having no effect on the final executable size or performance
B
Single-line comments are kept for debugging, multi-line comments are removed
C
Comments are converted to machine code instructions for runtime documentation
D
Comments are stored in a separate debug section of the executable file
9

Question 9

When developing a C++ library that will be used by other programs, what considerations should be made regarding the main function and program structure?

A
Libraries should not contain main functions, only provide reusable functions and classes for other programs to call
B
Every C++ file must have a main function, even in libraries
C
Libraries can have main functions that are conditionally compiled out
D
Main functions in libraries serve as example usage demonstrations
10

Question 10

In a complex C++ build system where multiple source files include the same standard headers, how does the preprocessor prevent duplicate symbol definitions?

A
Header guards (#ifndef/#define/#endif) or #pragma once prevent multiple inclusion of the same header content
B
The compiler automatically detects and removes duplicate includes during compilation
C
Duplicate includes are allowed and resolved by the linker through symbol resolution
D
Standard library headers cannot be included multiple times and will cause compilation errors

Other Quiz Categories

JavaScript
47 quizzes
Basics
Variables & Data Types
Operators & Expressions
Rust
30 quizzes
Cargo and Project Setup
Variables and Mutability
Data Types
Python
29 quizzes
Introduction & Core Fundamentals
Data Types Overview
Type Casting
Golang
29 quizzes
Basics & Syntax
Data Types & Zero Values
Operators & Expressions
Java
22 quizzes
Java Basics & JVM Fundamentals
Variables, Data Types & Type Casting
Operators & Expressions
Matlab
21 quizzes
Basics & Environment
Variables and Data Type
Arrays and Matric
TypeScript
19 quizzes
Introduction and Overview
Installation and Configuration
Basic Types and Type Annotations
SQL Database
15 quizzes
Foundations and Basics
Basic Query Selection
Filter, Sort, and Alias Essentials
PHP
15 quizzes
Syntax Building Blocks
Variable Naming
Data Types Overview
Linked List
11 quizzes
Introduction
Node Structure and Pointer Fundamentals
Singly Linked List

QUIZZES IN C++

1

Basics

10

40 in-depth questions covering C++ fundamentals, program structure, input/output operations, comments, compilation process, and exit codes — with 10 code examples to solidify understanding.

2

Variables & Data Types

40

40 in-depth questions covering C++ fundamental types, type modifiers, auto inference, type ranges, literals, and initialization patterns — with 10 code examples to solidify understanding.

3

Operators & Expression

40

40 in-depth questions covering C++ arithmetic, comparison, logical operators, compound assignments, and precedence rules — with 10 code examples to solidify understanding.

4

Control Flow

40

40 in-depth questions covering C++ control flow statements including conditional execution, loops, and flow control mechanisms — with 10 code examples to solidify understanding.

5

Function

40

40 in-depth questions covering C++ function fundamentals including declaration, parameters, overloading, passing mechanisms, and inline functions — with 10 code examples to solidify understanding.

6

Arrays & Strings

40

40 comprehensive questions on C++ arrays and strings, covering fixed-size arrays, C-style strings, std::string fundamentals, string operations, and array iteration patterns — with 20 code examples to master memory management and string handling.

7

Pointer

40

Master the fundamentals of C++ pointers including declaration, dereferencing, null pointers, pointer arithmetic, and advanced concepts like pointers to arrays and pointers to pointers.

8

References

40

Explore C++ references including binding rules, differences from pointers, const references, returning references, and reference lifetime management for safe and efficient code.

9

Dynamic Memory

35

Comprehensive C++ quiz exploring dynamic memory management including new/delete operators, array allocation, memory leaks, dangling pointers, and the motivation for smart pointers in modern C++.

10

Structs & Basic Classes

40

Comprehensive C++ quiz exploring fundamental object-oriented programming concepts including struct vs class differences, member variables, methods, access specifiers, and object initialization patterns.

11

Constructors & Destructors

40

40 in-depth questions covering C++ constructors and destructors, including default/parameterized constructors, initializer lists, copy/move constructors, and RAII concepts — with 16 code examples to master object lifecycle management.

12

Operator Overloading

35

35 in-depth questions covering C++ operator overloading, including arithmetic operators, comparison operators, stream operators, assignment rules, and best practices — with 16 code examples to master operator design and pitfalls.

13

The Standard Template Library (STL)

40

40 in-depth questions covering C++ STL fundamentals including std::vector, std::map, std::unordered_map, std::pair, std::tuple, std::set, and best practices for containers — with 16 code examples to master STL usage and pitfalls.

14

Iterator

40

40 in-depth questions covering C++ iterator fundamentals including iterator categories, STL container usage, begin/end patterns, reverse iterators, and iterator invalidation rules — with 16 code examples to master iterator-based programming.

15

OOP: Inheritance

40

40 in-depth questions covering C++ inheritance fundamentals including base and derived classes, protected members, method overriding, final and override keywords, and inheritance best practices — with 16 code examples to master object-oriented inheritance patterns.

16

OOP: Polymorphism

40

40 in-depth questions covering C++ polymorphism fundamentals including virtual functions, pure virtual functions, abstract classes, virtual destructors, and dynamic dispatch — with 16 code examples to master runtime polymorphism patterns.

17

Templates & Generics

40

40 in-depth questions covering C++ template fundamentals including function templates, class templates, template type deduction, non-type template parameters, and generic programming style — with 16 code examples to master compile-time polymorphism patterns.

18

Exception Handling

40

40 in-depth questions covering C++ exception handling mechanisms, try/catch/throw blocks, exception types, stack unwinding, custom exceptions, and noexcept specification — with 16 code examples to solidify understanding.

19

File I/O

40

40 in-depth questions covering C++ file input/output operations, stream classes, text and binary file handling, error checking, and RAII patterns — with 16 code examples to solidify understanding.

20

Smart Pointer

40

40 in-depth questions covering C++ smart pointer types, ownership semantics, memory management, and cyclic reference avoidance — with 16 code examples to solidify understanding.

21

Move Semantics & Perfect Forwarding

40

40 in-depth questions covering C++ move semantics, rvalue references, move constructors, std::move, perfect forwarding with std::forward, and performance considerations — with 16 code examples to solidify understanding.

22

Lambda Expressions

40

40 in-depth questions covering C++ lambda expressions, capture lists, mutable lambdas, returning lambdas, storing lambdas in std::function, and lambda recursion techniques — with 16 code examples to solidify understanding.

23

Concurrency

40

40 in-depth questions covering C++ concurrency with std::thread, thread synchronization, mutex types, condition variables, and race condition avoidance — with 16 code examples to solidify understanding.

24

Async & Futures

40

40 in-depth questions covering C++ async programming with std::async, std::future, std::promise, task-based concurrency, and custom thread pool patterns — with 16 code examples to solidify understanding.

25

Memory Management Deep Dive

40

40 in-depth questions covering advanced C++ memory management with custom allocators, memory pools, RAII patterns, and cache-friendly programming — with 16 code examples to solidify understanding.

26

Advanced Templates

40

40 in-depth questions covering advanced C++ template metaprogramming with SFINAE, variadic templates, constexpr, and compile-time computation — with 16 code examples to solidify understanding.