{"id":30,"date":"2017-05-21T15:11:29","date_gmt":"2017-05-21T22:11:29","guid":{"rendered":"http:\/\/codingrestart.com\/?p=30"},"modified":"2017-05-21T15:11:29","modified_gmt":"2017-05-21T22:11:29","slug":"why-is-smart-pointer-better","status":"publish","type":"post","link":"https:\/\/codingrestart.com\/home\/why-is-smart-pointer-better\/","title":{"rendered":"Why is smart pointer better than a raw one?"},"content":{"rendered":"

In a previous post<\/a>\u00a0I suggested that raw pointers should be replaced by smart pointers. This post explains why smart pointers are better than raw ones and how to convert an existing code using raw pointers to use smart pointers. For the sake of this post, when I refer to smart pointers, I talk about unique pointers, unique_ptr.<\/p>\n

Why is smart pointer better?<\/h4>\n

Smart pointers have one crucial advantage over raw pointers: they guarantee that their destructors are called during stack unwinding. That means that any memory allocated in constructors will be automatically freed.<\/p>\n

Let’s look at sample code, that illustrates the advantage of smart pointers over raw pointers. First, let’s define a simple class that owns some memory, say std::string to store text.<\/p>\n

class Test
\n{
\n string s;
\npublic:
\n Test(string sVariable) :
\n  s(sVariable)
\n {
\n  cout << \"Constructor (\" << s << \")...\" << endl;
\n };
\n ~Test()
\n {
\n  cout << \"Destructor (\" << s << \")...\" << endl;
\n };
\n};<\/code><\/p>\n

Now assume that the main function will call myFunction() method to perform some operations. Main will catch any exceptions generated in myFunction() and exit the program.<\/p>\n

int main()
\n{
\n try
\n {
\n  myFunction();
\n }
\n catch(...)
\n {
\n  cout << \"Exception handled\" << endl;
\n }
\n 
\n cout << \"End\" << endl;
\n return 0;
\n}<\/code><\/p>\n

Now let’s declare two pointers to Test class in myFunction(). First is rawPointer, which is raw pointer, and then smartPointer which is a smart pointer. Then let’s throw an exception to simulate some unexpected behavior of myFunction. At the end of the function we delete rawPointer. Note, that a smartPointer variable is not deleted as its destructor is guaranteed when the variable goes out of scope.<\/p>\n

int myFunction()
\n{
\n cout << \"raw pointer\" << endl;
\n Test *rawPointer = new Test(\"raw pointer\");
\n 
\n cout << \"smart pointer\" << endl;
\n unique_ptr<Test> smartPointer = make_unique<Test>(\"smart pointer\");
\n 
\n cout << \"Throw!\" << endl;
\n throw;
\n 
\n cout << \"Delete raw\u00a0pointer\" << endl;
\n delete rawPointer;
\n 
\n return 0;
\n}<\/code><\/p>\n

When we run this code, we see the following output:<\/p>\n

raw\u00a0pointer
\nConstructor (raw pointer)...
\nsmart pointer
\nConstructor (smart pointer)...
\nThrow!
\nDestructor (smart pointer)...
\nException handled
\nEnd<\/code><\/p>\n

Notice, that rawPointer variable is never deleted, causing a memory leak to occur.<\/p>\n

How to convert raw pointers to smart pointers?<\/h3>\n

The above code provides a template how to convert existing code that is using raw pointers to smart pointers. To simplify the instructions, let’s use an example of code using raw pointers to int.<\/p>\n