C++ 01: unique_ptr prevents memory leaks скачать в хорошем качестве

C++ 01: unique_ptr prevents memory leaks

If you have used traditional pointers in a large project, one of the headaches is to make sure there are no dangling pointers floating somewhere undeleted that cause unclaimed memory, or memory leaks. For a simple and small project, it is not so hard to hunt down all the pointers and manually set them to null and delete them when no longer used, normally in the class destructor, assuming there is no exception to prevent reaching deletion of raw pointers. But for complex project developed by dozens of programmers, this becomes increasingly harder to do. Luckily there are solutions to cope with this problem. In modern C++ style programming, we should never need to manually delete or free the pointers, thanks to the smart pointers available in Boost library and in standard library. When you use smart pointers, destructors are automatically called when objects go out of scope. The dynamically allocated memory will then be automatically released, thus preventing memory leaks. In Boost library, there are several smart pointers available, like scoped, shared, weak, intrusive pointers. In C++ standard library, auto_ptr was defined in C++98. But due to its problems of transferring ownership when it's assigned, or can be described as "silently steals ownership", and cannot be used with an array of objects and standard containers like list, vector, map, auto_ptr has been directly replaced by unique_ptr found in C++11. unique_ptr combines the best features of std::auto_ptr and boost::scoped_ptr. In C++11 standard library, there are other smart pointers: shared_ptr, weak_ptr. In this tutorial, I will use an example to prove that when using unique_ptr, the destructor will be called automatically when the pointer is out of scope. (demo starts) In Visual Studio 2017, create a new project. Under Visual C++, Windows Desktop, Select Windows Console Application template. Change location to c:\tutorial. I know this folder exists on my machine. Change name to CppConsole01. Click OK to create the solution. Run with Ctrl + F5 to make sure no problem with the newly created project. Let's first include some necessary header files: iostream, and memory. To use unique_ptr, you need to include memory file. As starting point, create a class A. To make the code more concise for demo purpose, delete auto-generated code for constructor and destructor. In normal practice, you would use them in the implementation. Write constructor to accept an integer value. Also define a class scope variable m_val. In the constructor, assign the value. Display the message like: In class A's constructor. Let me add "using namespace std;" to fix the identifier is not found error. In the destructor, show message "In class A's destructor". Add one more method to return the value we received in the constructor. Now go to entry point main() function to use class A in a pointer. Declare a boolean variable bRet. Use it in if statement, so we arbitrarily create a code block to simulate scope. Declare pointer p points to class A object, using new keyword. Provide integer 3 required by constructor. If p is successfully created, we do something. If not, give a warning: p is empty. In if block, call GetVal() method in class A. This shows pointer p is working properly. Afterwards, before pointer p will go out of scope, let's display a message as marker. After pointer p is out of scope, display another message as another marker. Fix the typo: endl. Now the demo program using traditional pointer is finished. Let's running it without debugging. The output shows in A's constructor, and value equals 3. These are associated with class A's constructor, and calling A's method GetVal(). More interesting part is this: p will be out of scope, and p is out of scope. (demo starts) Here is the code used in the demo. Part one defines class A. Part two is the main function of the demo program. Here is a summary of what we have learned. Declare and instantiate unique_pointer with type A using make_unique method. Unique_ptr is available since C++11 standard library. Make_unique method is available since C++14 standard library. To set which C++ standard library should be used in your project, go to project properties language settings in Visual Studio. The takeaway from this tutorial is to start using unique_ptr or other smart pointers available sinceC++11 standard library in your projects, if you haven't done so. In the next tutorial, I will continue with unique_ptr on its uniqueness. Thanks for watching!