Mithat Konar (the wiki)

User Tools

Site Tools

You are here: Mithat Konar (the wiki) » C++ notes » Pointers 4
cplusplus:pointers_4

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
Last revisionBoth sides next revision
cplusplus:pointers_4 [2016/03/21 23:52] – [Smart Pointers] mithatcplusplus:pointers_4 [2019/03/31 21:45] – mithat
Line 17: Line 17:
 </code> </code>
  
-''foo'' now points to a ''double'' that is //not// a variable.+''foo'' now points to a ''double'' that is //not// associated with a variable identifier.
  
 <file cpp simple-allocation.cpp> <file cpp simple-allocation.cpp>
Line 172: Line 172:
 **Deallocation** is the process of releasing back to the OS storage that was previously dynamically allocated.  **Deallocation** is the process of releasing back to the OS storage that was previously dynamically allocated. 
  
-//Any memory that has been dynamically allocated must be deallocated (i.e., released back to the OS) somewhere in the program, otherwise a memory leak will result.// +Deallocation of dynamically allocated storage does not happen automatically in C++, therefore you must explicitly (i.e., manually) deallocate the memory. The ''delete'' operator lets you explicitly deallocate memory that has been dynamically allocated.
  
-Since deallocation of dynamically allocated storage does not happen automatically in C++, you must explicitly (i.e., manually) deallocate the memory. The ''delete'' operator lets you explicitly deallocate memory that has been dynamically allocated.+<WRAP center round tip 90%> 
 +Any memory that you have dynamically allocated must be deallocated somewhere in the program. Otherwise a memory leak will result. 
 +</WRAP>
  
 The code below fixes the memory leak introduced above: The code below fixes the memory leak introduced above:
Line 233: Line 235:
     for (count = 0; count < numDays; count++)     for (count = 0; count < numDays; count++)
     {     {
- cout << "Day " << (count + 1) << ": "; +        cout << "Day " << (count + 1) << ": "; 
- cin >> sales[count];+        cin >> sales[count];
     }     }
  
Line 240: Line 242:
     for (count = 0; count < numDays; count++)     for (count = 0; count < numDays; count++)
     {     {
- total += sales[count];+        total += sales[count];
     }     }
  
Line 261: Line 263:
 ==== heap vs. stack ==== ==== heap vs. stack ====
  
-Up to now, we may have given the impression that local variables and dynamically allocated storage are both allocated memory from the same amorphous pool of RAM. This is not the case. The **stack** is a pool of memory whose allocation and deallocation is automatically managed. Local variables (and global ones too) are allocated from the stack. The **heap** is a pool of memory whose allocation and deallocation is explicitly (i.e., manually) managed. Dynamically allocated memory are allocated from the heap.+Up to now, we may have given the impression that local variables and dynamically allocated storage are both allocated memory from the same pool of RAM. This is not the case. The **stack** is a pool of memory whose allocation and deallocation is automatically managed. Local variables (and global ones too) are allocated from the stack. The **heap** is a pool of memory whose allocation and deallocation is explicitly managed. Dynamically allocated storage is allocated from the heap.
  
 A more detailed discussion of the heap versus the stack, while important, is beyond the scope of the present discussion. But it is important to know that there are two different memory pools that C++ programs draw from. A more detailed discussion of the heap versus the stack, while important, is beyond the scope of the present discussion. But it is important to know that there are two different memory pools that C++ programs draw from.
Line 364: Line 366:
  
 ===== Smart Pointers ===== ===== Smart Pointers =====
-<WRAP center round todo 60%> 
-TODO 
-</WRAP> 
- 
 C++11's //smart pointers// manage their own memory to help mitigate memory leaks. To use smart pointers, you need to ''#include <memory>''. C++11's //smart pointers// manage their own memory to help mitigate memory leaks. To use smart pointers, you need to ''#include <memory>''.
  
 One smart pointer is the ''unique_ptr'': One smart pointer is the ''unique_ptr'':
  
- +''**unique_ptr<**//type_pointed_to//**>** //pointer_name//**(** //expression_to_allocate_memory// **)**''
-''**unique_ptr<**//type_pointed_to//**>** //pointer_name//**(** //expression to allocate memory// **)**'' +
  
 <file c++ Gaddis-Pr9-17.cpp> <file c++ Gaddis-Pr9-17.cpp>
cplusplus/pointers_4.txt · Last modified: 2019/03/31 22:35 by mithat
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki