2.2 Pointers Can Be Dangerous

Because pointers provide access a memory location and because data and executable code exist in memory together, misuses of pointers can lead to both  bizarre effects and very subtle errors.

Potential Problems with Pointers   

• uninitialized pointers,
• memory leaks and
• dangling pointers.

Uninitialized pointers   

• Uninitialized pointer pose a significant thread.
  • the value stored in an uninitialized pointer could be randomly pointing anywhere in memory.
  • Storing a value using an uninitialized pointer has the potential to overwrite anything in your program, including your program itself
• Your best defense:

  Never write a declaration like

  
  
  
  
  
  
  Money
  * 
  p
  ;
      
  
  
  
  
  
  

  Always give your pointers an initial value

  
  
  
  
  
  
  Money
  * 
  p 
  = 
  0;
      
  
  
  
  
  
  

  • Null if you can’t make it point to a real data value.

Memory Leaks   

A memory leak occurs when all pointers to a value allocated on the heap has been lost, e.g.,

int 
isqrt 
(
int 
i
)





{




 
int
* 
work 
= 
new 
int
;




 
*
work 
= 
i
;




 
while 
((
*
work
) 
* 
(
*
work
) 
> 
i
)




 
-
- 
(
*
work
);




 
return 
*
work
;





}
  

• When we return from this function the local variable work is lost.
  • But that has the only copy of the address of the int that we allocated on the heap.
• Each call to this function will leak a bit of memory.

Over time, memory leaks can cause programs to slow down and, eventually, crash.

Worse, a leaky program may come to take up so much of a systems memory that it interferes with the operation of other programs on the same system.

Dangling Pointers   

Dangling pointers refer to a pointer which was pointing at an object that has been deleted.

int
* 
p 
= 
new 
int
;





int
* 
q 
= 
p
;

⋮

delete 
p
;
  

• The pointer q still has the address of the object even though the memory for that object has been returned to the system.
• If the memory allocated to the deleted object is re-used for another purpose,
  • The value visible via q may appear to “spontaneously” change
  • Storing a value via q may corrupt that other data