Review on pointers and dynamic objects

Memory Management

Static Memory Allocation Memory is allocated at compiling time

Dynamic Memory Memory is allocated at running time

{ int a[200]; …}

{ int n; cin >> n; a[n]???}

Static vs. Dynamic Objects Static object

Memory is acquired automatically

Memory is returned automatically when object goes out of scope

Dynamic object Memory is acquired by

program with an allocation request

new operation Dynamic objects can

exist beyond the function in which they were allocated

Object memory is returned by a deallocation request

delete operation

Why pointers?Dynamic objects are ‘implemented’ or ‘realized’ by

‘pointers’ which are parts of low-level ‘physical memory’

We don’t like it, but can not avoid it.

Low level languages directly manipulate them

High level languages want to ‘hide’ the pointers (conceptually remove them)

Pointers A pointer is a variable used for storing the address of

a memory cell. We can use the pointer to reference this memory cell

100100…… …… 10241024 ……Memory address: 1024 10032

……1020

Integer a Pointer p

int a;

int* p;

a

Getting an address: address operator &

int a=100; “&a” “the address of a”

100100…… …… …… ……Memory address: 1024

int a = 100;

cout << a; 100

Cout << &a; 1024

……1020

a

Dereferencing Operator * We can access to the value stored in the variable

pointed to by preceding the pointer with the “star” operator (*),

1001008888 …… 10241024 ……Memory address: 1024 10032

……1020

int a = 100;

int* p = &a;

cout << a << endl;

cout << &a << endl;

cout << p << " " << *p << endl;

cout << &p << endl;

a p

*p gives 100

Pointer to pointer …

int a;

int* p;

int** q;

a = 58;

p = &a;

q = &p;

a p q

58

a, *p, and **q are the same object whose value is 58!

But q = &a is illegal!

An asterisk (‘*’) has two usages

In a definition, an asterisk indicates that the object is a pointer.

char* s; // s is of type pointer to char

(char *s; is possible)

In expressions, an asterisk before a pointer indicates the object the pointer pointed to, called dereferencing

int i = 1, j;

int* ptr; // ptr is an int pointer

ptr = &i; // ptr points to i

j = *ptr + 1; // j is assigned 2

cout << *ptr << j << endl; // display "12"

Writing pointer type properly in C++ …

int *a, *b;

a, b are both integer pointers

int* a, b;

a is integer pointer, b is just integer!

typedefine int* IntPt;

IntPt a, b;

typedefine int MyInt;

MyInt k;int k;

int* a;

int* b;?

Recommended!!!

I don’t like this!

Summary * has two usages:

- pointer type definition: int a;

int* p;

- dereferencing: *p is an integer variable if

p = &a;

& has two usages:

- getting address: p = &a;

- reference: int& b a;

b is an alternative name for a

First application in passing parameters (‘swap’ example)

int a=10;

int b=100;

int* p;

int* q;

P = &a;

Q = &b;

p = q;

*p = *q;

?

?

Pointers and References

Reference (implemented as a (const) pointer) is an abstraction,

Not available in C, only in C++.

A pointer can be assigned a new value to point at a different object, but a reference variable always refers to the same object. Assigning a reference variable with a new value actually changes the value of the referred object.

int* p;int m = 10;int& j = m; //validp = &m; //p now points at m

int n = 12;j = n; //the value of m is set to 12. But j still refers to m, not to n.

cout << “value of m = “ << m <<endl; //value of m printed is 12

n = 36;Cout << “value of j = “ << j << endl; //value of j printed is 12

p = &n;

Pointer vs. Reference

A reference variable is different from a pointer

int x=10;

int* ref;

Ref = &x;

int x=10;

int& ref = x;

x

ref

10

int& ref;

10x

ref

Traditional Pointer Usagevoid swap(char* ptr1, char* ptr2){

char temp = *ptr1;*ptr1 = *ptr2;*ptr2 = temp;

}int main() {

char a = 'y';char b = 'n';swap(&a, &b);cout << a << b << endl;return 0;

}

Uese pass-by-value of pointers to ‘change’ variable values

C language does not have ‘call by reference’!

Pass by Reference (better than ‘pointers’)

void swap(char& y, char& z) {char temp = y;y = z;z = temp;

}int main() {

char a = 'y';char b = 'n';swap(a, b);cout << a << b << endl;return 0;

}

y, z are ‘references’, only names, not like ptr1, ptr2 that are variables

Pointers and Arrays

Double faces of an array: int a[10] a is the name of an array, a is also is a constant pointer to its first element

Pointers and Arrays

The name of an array points only to the first element not the whole array.

2

4

8

6

22a[4]

a[0]

a[2]

a[1]

a[3]

a

Result is:

2

2

2

#include <iostream>

Using namespace std;

void main(){

int a[5] = {2,4,6,8,22};

cout << *a << " "

<< a[0] << " "

<< *(&a[0]);

..."

} //main

2

4

8

6

22a[4]

a[0]

a[2]

a[1]

a[3]

Dereference of an array name

This element is called a[0] or *a

To access an array, any pointer to the first element can be used instead of the name of the array.

We could replace *p by *a

#include <iostream>

Using namespace std;

void main(){

int a[5] = {2,4,6,8,22};

int* p = a;

int i = 0;

cout << a[i] << " "

<< *p;

...

}

2

4

8

6

22a[4]

a[0]

a[2]a[1]

a[3]

a p

a

Array name as pointer

2

2

dynamic objects

Static variables (objects) Dynamic variables (objects)

A (direct) named memory location A static part (pointer) + (indirect) nameless memory location

(dynamic part)int a;

a = 20;int* pa;

pa = new int;

*pa = 20;

20a 20pa

static static dynamic

Summary

int* p = new int;

*p = 10;

delete p;

p 10 p 10

int* p = new int[100];

for (i=1;i<100;i++)

p[i] = 10;

delete[] p;

Simple dynamic variable Dynamic array

‘delete p’ is not sufficient

for an array!!!

‘delete’ two actions:

1. Return the object pointed to

2. Point the pointer p to NULL

10 10