2. Pointer Yan Shi CS/SE2630 Lecture Notes - PowerPoint Presentation

Slide1

2. Pointer

Yan Shi

CS/SE2630 Lecture NotesSlide2

2

C++ Data Types

structured

array struct union class

address

pointer reference

simple

integral

enum

char short int long bool

floating

float double long doubleSlide3

What is reference?

simple data type:

reference operator &

the address of a variable of certain data type

int num

= 10; int &

rNum = num

;Do you remember?an array or object must be passed as a reference parameterint

nums[10];Student

stu;

StudentList stuList

;…

avg = Average(nums

);stuList.Add(stu

);Once a reference is created, it cannot be later made to

refer another variable/object; it cannot be reseated.

int

Average( const int

myArray[] );

void Add( const Student& stu );Slide4

What is a pointer variable?

A pointer variable is a variable

whose value is the address of a location in memory

.

Unlike a reference variable, a pointer can redirect to other locations later.

To declare a pointer variable, you must specify the type of value that the pointer will point to.

int *p;

// p will hold the address of an int

char *q;

// q will hold the address of a

charint

a, *b; // * is paired with the identifier.

// In this case, we have a int

variable a and // a pointer of

int

type bSlide5

For a normal variable

int

num;

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

?

num

0010Slide6

For a normal variable

int

num;num = 50;

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

50

num

0010Slide7

Pointer

int

num;num

= 50;int *p;

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

50

num

0010

?

p

0012

A pointer variable contains the

memory

address of another variable.Slide8

Pointer

int

num;num

= 50;int *p;p = &

num;

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

50

num

0010

0010

p

0012

& is the reference(address-of )operator.Slide9

Pointer

int

num;num

= 50;int *p;p = &

num;cout << *p;

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

50

num

0010

(*) here is the dereference operator.

*p is used to access the place p points to.

 you will see 50 on the screen.

0010

p

0012Slide10

Pointer

int

num;num

= 50;int *p;p = &

num;cout << *p;

*p = 100;

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

100

num

0010

change the value at the address p

points

to 100

0010

p

0012

//direct addressing

//indirect addressingSlide11

char

ch

;

ch

= ‘

A’;

char* q;

q = &

ch;

*q =

‘Z’

; char* p;

p = q;

// the right side has value 4000 // now p and q both point to ch

Another Example

4000

A Z

ch

5000 6000

4000 4000

q p

Slide12

NULL pointer

Use NULL to initialize pointers that don’t currently point to anything.

used to initialize pointers

can be converted to pointers of any type<cstddef>

int *p = NULL;

It is an error to dereference a pointer whose value is NULL. It is the programmer’

s job to check for this.Slide13

Dynamic Memory Allocation

In the previous example, memory space for

num

and p are statically allocated at compile timefrom

stack memory (activation records)Dynamic memory allocationat run timefrom

heap memory (free store: dynamic)In java, all user-defined types are allocated from heapIn C++, use

new operator to get data from heapSlide14

Dynamic Memory Allocation

int

*p

= new int;

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

p

0010Slide15

Dynamic Memory Allocation

int

*p =

new int;

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

?

p

0010

unnamed

dynamically

allocated

integer variable

(from heap)

0080Slide16

Dynamic Memory Allocation

int

*p = new

int;

With Initialization:int *p = new int

(99);

.

.

.

.

.

.

Memory

Address

identifier

.

.

.

?

p

0010

0080

0080

The dynamically allocated variable

can only be indirectly addressed

through the pointer returned by

new

.

unnamed

dynamically

allocated

integer variable

(from heap)Slide17

What does

new

do?

It takes a pointer variable, allocates heap memory for it to point, and leaves the address of the assigned memory in the pointer variable.

If there is no more memory, the pointer variable is set to NULL.Slide18

Dynamic Array

Using

new

, now we can dynamically decide the size of an array. int

size; cin >> size;

char *text = new char[size];Slide19

Memory Leak

Memory is allocated but not released



causing an application to consume memory

reducing the available memory for other applications and 

eventually causing the system to page virtual memory to the hard drive 

slowing the application or crashing the application when the computer memory resource limits are reached. 

Example: int

*p1 = new int;

int *p2 = new int

(99); *p1 = 10;

p2 = p1; // The memory cell p2 originally

// points at now can no longer be

// accessed

 this is called garbage.Slide20

Deallocate Memory: delete

delete

operator is used to return to the heap a memory location allocated previously by the

new operator.A pointer

p is pointing to a dynamically allocated space. When to delete p?

p is about to point to another space and no other pointer is pointing at the same location as p;right before the program exit.

int

*p1 = new int

;

int

*p2 = new int(99);

*p1 = 10;

delete p2; // This prevents memory leak.

p2 = p1;

… int

*a = new int[n

];

… delete[] a; //

deallocate the entire array space.Slide21

Enable Memory Leak Detection

Visual Studio provides

 C Run-Time Libraries (CRT) debug heap

functions. To enable:include in the exact order.add

_CrtDumpMemoryLeaks(); immediately before the program exit.

When you run your program under the debugger, _CrtDumpMemoryLeaks displays memory leak information in the Output window.

#define _CRTDBG_MAP_ALLOC

#include <

stdlib.h

>

#include <

crtdbg.h

>

Slide22

Stack vs Heap Memory Summary

Stack:

Memory allocated on the stack stays in scope as long as it is on the stack. It is destroyed when it is popped off the stack.

All memory allocated on the stack is known at compile time. Consequently, this memory can be accessed directly through a variable. Because the stack is relatively small, it is generally not a good idea to do anything that eats up lots of stack space. This includes allocating large arrays, structures, and classes, as well as heavy recursion.

Heap:Allocated memory stays allocated until it is specifically deallocated (beware memory leaks).Dynamically

allocated memory must be accessed through a pointer.Because the heap is a big pool of memory, large arrays, structures, or classes should be allocated here.Slide23

Pointers and Arrays

C++ arrays are not objects as in Java. They are really just pointers!

char

name[30];

// name is actually

&name[0]char *np

;np

= &name[0]; // same as np = name;C++ allows pointer arithmetic:

…cin

>> *np

;while( *

np != ‘/n’ ){

np++;

cin >> *np;

}name is a constant pointer.

name[i

] is the same as *(name + i

)// hope that all names are

// shorter than 30

characters

// moves np

ahead sizeof(char) bytes // and points to the next element.Slide24

Pointer Arithmetics

char b, *p, s[9] = “SOFTWARE”

b

= *(s+1)+1;?b

= *s-1;?p = s+7; b = *--p;?Precedence of prefix ++ and * is same. Associativity of both is right to

left.Precedence of postfix ++ is higher than both * and prefix ++. Associativity of postfix ++ is left to right.*p++ // same as *(p

++): increment pointer, and dereference unincremented address*++p // same as *(++p): increment pointer, and dereference incremented address++*p // same as ++(*p): dereference pointer, and increment the value it points to

(*p)++ // dereference pointer, and post-increment the value it points to Slide25

Pointers and Objects

How to declare an object?

Student stu(…); OR

Student *stu = new Student(…);

For the second declaration, we can make a public method call like this:

stu->GetGPA();

// stu

is a Student object// located at the stack memory

//

stu is a pointer of Student type

// located at the heap memory

// This is the same as

// (*stu).

GetGPA

();Slide26

Pointers and Objects

We can make a dynamic array of objects:

Student * stuList

= new Student[n];In this case,

Student must have a default constructor!An alternative is to make a dynamic array of Student pointers

Student **stuList

= new Student*[n];In this case, no default constructor is needed, but memory management becomes more complicated.Slide27

Pointers and const

Const

pointers can read the value pointed, but cannot modify it.

As a safety feature, pointers to const are not implicitly convertible to pointers to non-const. A function that takes a pointer to non-

const as parameter can modify the value passed as argument, while a function that takes a pointer to const as parameter cannot.

int

x, y = 10;

const

int * p = &y;

x = *p;

//

ok:reading

p

*

p = x; // error:

modifying

p, which is

const-qualified

void

print_all

(

const

int

* start,

const

int

* stop

) {

const

int

* current = start;

while

(current != stop) {

cout

<< *current << '\n';

++current;

// increment pointer

}

} Slide28

Dangling Pointer

Pointers that do not point to a valid object.

Dangling pointers arise when an object is deleted or

deallocated, without modifying the value of the pointer, so that the pointer still points to the memory location of the deallocated memory.If later

the program dereferences the (now) dangling pointer, unpredictable behavior may result.That is why Java introduced automatic garbage collection! Slide29

Dangling Pointer Example

8

ptr

-5

ptr2

int

*

ptr

= new

int

;

*

ptr

= 8;

int

* ptr2 = new

int

;

*ptr2 = -5;

ptr

= ptr2;

8 cannot be addressed and thus become a garbageSlide30

Dangling Pointer Example

int

* ptr = new

int; *ptr

= 8; int* ptr2 = new int

; *ptr2 = -5; ptr

= ptr2; delete ptr2

;// ptr is left dangling

ptr2 = NULL;

8

ptr

NULL

ptr2

Slide31

Dangling Pointer Example

common mistake: returning address of local data

Both create dangling pointers!

xyz will be deleted after the function call

returned pointer will be pointing to empty slot.

X* foo() {

X xyz;

... operate on xyz ... return &xyz

;}

char* g()

{ char str[100];

... operate on str ... return

str; }Slide32

Void Pointer

void

pointers are pointers that point to a value that has no type  it can point to objects of any type!

void * p;

int

nValue = 10; char

str[] = “Hello”;

p = &

nValue;

p = str

;

A void pointer must be explicitly cast into another type of pointer to be dereferenced.

cout <<

*

static_cast<char*>(

p) << endl

;In general, it is a good idea to avoid using void pointers unless absolutely necessary, as they effectively allow you to avoid type checking.

What’s the difference between a void pointer and a null pointer?