**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Memory Management and Resource Management **Topic:** Understanding dynamic memory allocation (`new`, `delete`, `malloc`, `free`) **Overview** Dynamic memory allocation is a crucial aspect of C++ programming that allows you to allocate and deallocate memory at runtime. In this topic, we will delve into the world of dynamic memory allocation using `new`, `delete`, `malloc`, and `free`. We will explore the differences between these operators, and when to use each. **Understanding `new` and `delete`** In C++, `new` is used to allocate memory dynamically. The syntax is as follows: ```cpp int* ptr = new int; ``` This allocates a single integer on the heap and returns a pointer to it. To deallocate the memory, use the `delete` operator: ```cpp delete ptr; ``` Note: Make sure to delete the memory you allocate to prevent memory leaks. You can also allocate arrays using `new`: ```cpp int* arr = new int[10]; ``` To deallocate an array, use the `delete[]` operator: ```cpp delete[] arr; ``` **Understanding `malloc` and `free`** `malloc` and `free` are part of the C standard library, and are not exclusively C++. However, you can still use them in C++ programming. ```cpp int* ptr = (int*)malloc(sizeof(int)); ``` This allocates a single integer on the heap and returns a pointer to it. The `sizeof` operator returns the size of the `int` type. To deallocate the memory, use the `free` function: ```cpp free(ptr); ``` **Key Differences** * `new` returns a typed pointer, while `malloc` returns a void pointer, which must be cast to the desired type. * `new` can throw an exception when out of memory, while `malloc` returns a null pointer. * `new` calls the constructor of the object, while `malloc` does not. **Best Practices** * Use `new` and `delete` instead of `malloc` and `free` unless you have a specific reason to use the latter (e.g., interacting with C code). * Always check for failed allocation when using `new` or `malloc`. * Use `delete[]` to deallocate arrays allocated with `new[]`. **Example Use Case** Here's an example of dynamic memory allocation using `new` and `delete`: ```cpp #include <iostream> int main() { int* arr = new int[10]; for (int i = 0; i < 10; i++) { arr[i] = i * 2; std::cout << arr[i] << " "; } delete[] arr; return 0; } ``` In this example, an array of size 10 is allocated dynamically using `new`. Then, each element is assigned a value, and the array is printed to the console. Finally, the memory is deallocated using `delete[]`. **Common Errors** * Memory leak: Not freeing memory after allocation. * Dangling pointer: Using a pointer after the memory it points to has been freed. * Double delete: Freeing the same memory twice. **Conclusion** In this topic, we have explored dynamic memory allocation using `new`, `delete`, `malloc`, and `free`. Remember to use `new` and `delete` instead of `malloc` and `free`, check for failed allocation, and always free memory when you're done with it. **Additional Resources** * The official C++ documentation: [ https://en.cppreference.com/w/cpp/keywords/new](https://en.cppreference.com/w/cpp/keywords/new) * Stack Overflow Q&A: [ https://stackoverflow.com/questions/655065/when-should-i-use-the-new-keyword-in-c](https://stackoverflow.com/questions/655065/when-should-i-use-the-new-keyword-in-c) If you have any questions or comments about this topic, feel free to ask below! --- --- For our next topic, RAII (Resource Acquisition Is Initialization) and smart pointers for resource management.