**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Memory Management and Resource Management **Topic:** Write a C++ program managing dynamic memory efficiently using RAII and smart pointers.(Lab topic) **Introduction** In the previous topics, we covered the basics of dynamic memory allocation using `new` and `delete`. However, manual memory management can lead to memory leaks and dangling pointers, causing issues that are difficult to debug and resolve. To address this, modern C++ provides RAII (Resource Acquisition Is Initialization) and smart pointers as best practices for efficient and safe memory management. In this topic, we'll explore how to write a C++ program that utilizes RAII and smart pointers to manage dynamic memory efficiently. **What is RAII?** RAII is a C++ idiom that ensures resources, including dynamically allocated memory, are properly cleaned up when they go out of scope. RAII uses classes to manage resources and calls constructors to acquire resources and destructors to release resources. This idiom helps to reduce the risk of memory leaks and dangling pointers. **What are Smart Pointers?** Smart pointers are classes that provide automatic memory management, eliminating the need to manually call `delete`. The three main types of smart pointers are: 1. `std::unique_ptr`: provides exclusive ownership of an object 2. `std::shared_ptr`: provides shared ownership of an object 3. `std::weak_ptr`: provides weak ownership of an object **Lab: Write a C++ Program Managing Dynamic Memory Efficiently** The task is to write a C++ program that uses RAII and smart pointers to manage dynamic memory efficiently. Specifically, you need to: 1. Define a `Resource` class that manages a dynamically allocated array. 2. Use a `std::unique_ptr` to manage the array. 3. Implement constructors, copy operations, and move operations for the `Resource` class. 4. Create objects and test the memory management efficiency. Here is a sample implementation: ```cpp #include <iostream> #include <memory> // Resource class that manages a dynamically allocated array class Resource { public: // Constructor Resource(int size) : data_(std::make_unique<int[]>(size)) { std::cout << "Constructor called. Array allocated with size " << size << std::endl; } // Move constructor Resource(Resource&&) = default; // Move assignment Resource& operator=(Resource&&) = default; // Disable copy constructor and copy assignment Resource(const Resource&) = delete; Resource& operator=(const Resource&) = delete; // Destructor ~Resource() { if (data_) { std::cout << "Destructor called. Array deallocated." << std::endl; } } // Access the array int* getData() const { return data_.get(); } private: std::unique_ptr<int[]> data_; }; int main() { // Create objects Resource res1(10); Resource res2 = std::move(Resource(20)); // Test memory management efficiency for (auto i = 0; i < 10; ++i) { std::cout << res1.getData()[i] << " "; } std::cout << std::endl; for (auto i = 0; i < 20; ++i) { std::cout << res2.getData()[i] << " "; } std::cout << std::endl; return 0; } ``` **Output** When you run the program, you should see that the constructors and destructors are called correctly, indicating efficient memory management. ```cpp Constructor called. Array allocated with size 10 Constructor called. Array allocated with size 20 Destructor called. Array deallocated. Destructor called. Array deallocated. ``` This example showcases how to use RAII and smart pointers to manage dynamic memory efficiently. You can apply this approach to other scenarios where dynamic memory allocation is required. **Practical Takeaways** 1. Use RAII to manage resources, such as dynamically allocated memory. 2. Prefer smart pointers (e.g., `std::unique_ptr`, `std::shared_ptr`) over raw pointers. 3. Disable copy operations for classes that manage resources. 4. Use move operations to transfer ownership of resources. **Next Topic:** Introduction to multithreading in C++ with the `<thread>` library. We will explore the basics of multithreading in C++, including creating threads, handling synchronization, and using the C++ `std::thread` library. After reading the above topic and running the code to demonstrate the material learned, Do you have any questions/uncertainties I can help clarify?.