Memory Management Quiz - Languages C++

Free practice quiz: Memory Management (Languages C++). 58 multiple-choice questions with answers and explanations. Play online, no sign-up needed.

This Languages C++ practice quiz has 58 multiple-choice questions on Memory Management, and 58 of them come with an explanation. Try the 5 sample questions below (tap an option to check yourself), then play the full quiz online. No sign-up needed.

Sample questions

1. In C++, what is the primary purpose of the `new` operator?

   1. To deallocate memory allocated on the stack.
   2. To allocate memory on the heap for a single object or an array of objects.
   3. To deallocate memory allocated on the heap.
   4. To allocate memory on the stack for a variable.
   Show answer

   Answer: B. To allocate memory on the heap for a single object or an array of objects.

   The `new` operator in C++ is used to dynamically allocate memory on the heap during runtime. It returns a pointer to the newly allocated memory. It can be used to allocate memory for a single object or for an array of objects. `delete` or `delete[]` are used for deallocation.

2. What is the primary role of a smart pointer (e.g., `std::unique_ptr`, `std::shared_ptr`) in C++ memory management?

   1. To provide direct low-level control over memory addresses.
   2. To automate memory deallocation and prevent memory leaks by managing the lifetime of dynamically allocated objects.
   3. To increase the size of allocated memory blocks.
   4. To perform garbage collection, similar to Java or Python.
   Show answer

   Answer: B. To automate memory deallocation and prevent memory leaks by managing the lifetime of dynamically allocated objects.

   Smart pointers are C++ objects that wrap raw pointers and automatically manage the memory they point to. They implement RAII principles, ensuring that the memory is deallocated when the smart pointer goes out of scope or when its ownership semantics dictate, thus preventing memory leaks and making manual `delete` calls largely unnecessary.

3. What is the potential consequence of calling `delete` on a pointer to an object that was created using `new[]`?

   1. It will correctly deallocate the entire array.
   2. It will deallocate only the first element of the array.
   3. It will lead to undefined behavior, potentially corrupting memory or crashing the program.
   4. It will successfully deallocate the memory and call destructors for all elements.
   Show answer

   Answer: C. It will lead to undefined behavior, potentially corrupting memory or crashing the program.

   When memory is allocated for an array using `new[]`, the compiler assumes that `delete[]` will be used for deallocation. Using `delete` instead of `delete[]` means that only the destructor for the first element (if it's a class type) might be called, and the deallocation of the remaining memory is not guaranteed to be correct, leading to undefined behavior.

4. What is a primary concern when using `void*` for generic memory manipulation in C++?

   1. It automatically performs type casting.
   2. It loses type information, requiring manual casting and increasing the risk of type-related errors.
   3. It guarantees memory safety.
   4. It is always more efficient than using specific pointer types.
   Show answer

   Answer: B. It loses type information, requiring manual casting and increasing the risk of type-related errors.

   A `void*` pointer is a generic pointer that can point to any data type. However, it does not carry any type information. To access the data it points to, you must explicitly cast it to the correct pointer type. This manual casting bypasses C++'s type checking mechanisms, making it prone to errors if the cast is incorrect, potentially leading to memory corruption or crashes.

5. What is the primary reason to use `std::weak_ptr`?

   1. To increase the reference count of a `std::shared_ptr`.
   2. To allow access to a managed object without affecting its lifetime, typically to break cyclic references between `std::shared_ptr`s.
   3. To exclusively own a dynamically allocated object.
   4. To perform garbage collection.
   Show answer

   Answer: B. To allow access to a managed object without affecting its lifetime, typically to break cyclic references between `std::shared_ptr`s.

   `std::weak_ptr` provides non-owning access to an object managed by `std::shared_ptr`. It does not increase the reference count. Its main use case is to break cyclic dependencies that can occur between `std::shared_ptr`s, which would otherwise prevent the objects from being deallocated. A `weak_ptr` can be converted to a `shared_ptr` using `lock()`, which will succeed only if the object still exists.

More questions in this quiz

Answers and explanations are in the full quiz.

1. What is the purpose of the `delete` operator in C++?
2. What is a memory leak in C++?
3. Which of the following is a consequence of using `delete` on a pointer that was not allocated with `new` or has already been deallocated?
4. What is the purpose of `new[]` and `delete[]` in C++?
5. Consider the following C++ code snippet: `int* ptr = new int; *ptr = 10; delete ptr; ptr = new int; *ptr = 20;`. What is the most critical aspect of memory management demonstrated here?
6. What is the risk associated with a dangling pointer in C++ memory management?
7. In C++, when would you typically use `malloc()` and `free()` over `new` and `delete`?
8. What is the primary advantage of RAII (Resource Acquisition Is Initialization) in C++ memory management?
9. Consider `std::vector<int> v; v.push_back(10);`. How is memory managed for the elements of `v`?
10. What happens to memory allocated with `new` if the program terminates unexpectedly (e.g., due to a crash) before `delete` is called?
11. If a class has a destructor that releases dynamically allocated memory, and an object of this class is created using `new`, what must be done to correctly deallocate its memory and execute its destructor?
12. What is the key difference between stack allocation and heap allocation in terms of scope and lifetime?
13. Consider the following code: `char* buffer = new char[100]; ... // some operations ... delete[] buffer;`. If an exception is thrown between the `new[]` and `delete[]` calls, what is the likely outcome without proper exception handling?
14. What is the purpose of `std::make_unique` in modern C++?
15. When using `std::shared_ptr`, how is memory deallocated?
16. What is a potential issue with a raw pointer managing dynamically allocated memory if the pointer itself goes out of scope without being `delete`d?
17. What does the `std::bad_alloc` exception signify in C++?
18. In C++, what is the purpose of `placement new`?
19. What is a common strategy to prevent memory leaks when managing raw pointers in C++?
20. Consider `int* arr = new int[5];`. If an exception occurs after this line but before `delete[] arr;`, and no exception handling is in place, what is the fate of the allocated memory?
21. What is the purpose of `std::move` in conjunction with smart pointers, particularly `std::unique_ptr`?
22. Which of the following best describes the concept of memory fragmentation?
23. What is the primary advantage of using `std::vector` over a raw dynamically allocated array (`int* arr = new int[size]; delete[] arr;`) for managing collections of elements?
24. If you have a `std::unique_ptr<MyClass> ptr(new MyClass());`, and you want to transfer ownership to another `std::unique_ptr`, how should you do it?
25. What is the primary characteristic of memory allocated on the heap?
26. What is the role of a destructor in C++ regarding memory management?
27. Consider this C++ code: `int* p = nullptr; { int x = 10; p = &x; }`. What is the state of `p` after the block `{}`, and why?
28. What is the primary motivation for using `std::make_shared` in C++?
29. In C++, what is the purpose of the `sizeof` operator in relation to memory allocation?
30. What is the key advantage of using `std::string` over a C-style character array (`char*`) for string manipulation in C++?
31. Consider the following code: `MyClass* obj = new MyClass(); ... obj->~MyClass();`. Is this the correct way to deallocate memory and destroy an object allocated with `new`?
32. What is the purpose of `std::vector::reserve()`?
33. In C++, what is the fundamental difference between an lvalue and an rvalue regarding memory?
34. What is the purpose of the `new` operator in C++ for object allocation?
35. What is the primary danger of using `realloc()` from `<cstdlib>` in C++ with C++ objects?
36. What is the role of the `std::unique_ptr` destructor?
37. Which of the following is the most fundamental reason for managing memory dynamically in C++?
38. What is the purpose of the `std::vector::shrink_to_fit()` member function?
39. What is a potential issue with relying solely on exception handling (`try-catch`) for memory management when using raw pointers?
40. What is the purpose of the `std::move` constructor or assignment operator?
41. What is the correct way to deallocate an array of integers allocated with `new int[10]`?
42. In C++, what is the purpose of `std::unique_ptr`?
43. What is the critical problem with implementing a custom memory allocator in C++ without careful consideration of alignment?
44. What is the purpose of the `std::bad_alloc::what()` method?
45. When is it generally recommended to use `malloc`/`free` instead of `new`/`delete` in a C++ program?
46. What is the primary benefit of using `std::vector`'s `emplace_back` over `push_back` when adding an object to the vector?
47. What is the role of the `std::allocator` in C++ standard library containers?
48. Consider the C++ code: `int* p = new int(5); int* q = p; delete p;`. What is the state of `q` after `delete p;`?
49. What is the purpose of `std::shared_ptr`?
50. What is the main advantage of RAII (Resource Acquisition Is Initialization) for managing dynamic memory in C++?
51. What does the `std::string::capacity()` method return?
52. What is the purpose of `delete static_cast<MyClass*>(ptr)` when `ptr` points to a single object allocated with `new MyClass()`?
53. Which C++ feature directly addresses the problem of memory leaks caused by unhandled exceptions when managing raw pointers?

More quizzes

• Multithreading▶ Play
• OOP▶ Play
• STL▶ Play
• Templates▶ Play

Browse all C++ quizzes

More to play