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 dont like it, but can not avoid it.

Low level languages directly manipulate them

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

 A pointer is a variable used for storing the address of a memory cell. We can use the pointer to reference this memory cell

Pointers

Memory address:

1020

1024

int a; int* p;
Integer a

100
a

10032

1024

Pointer p

Getting an address: address operator &

int a=100; &a the address of a
1024

Memory address: 1020

int a = 100; cout << a; Cout << &a;

100
a 100 1024

Dereferencing Operator *
We can access to the value stored in the variable pointed to by preceding the pointer with the star operator (*),
Memory address: 1020 1024 10032

88

100
a

*p

1024
p

int a = 100; int* p = &a; cout << a << endl; cout << &a << endl; cout << p << " " << *p << endl; cout << &p << endl;

gives 100

Pointer to pointer
int a; int* p; int** q;
58

a = 58; p = &a; q = &p;

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; int* b;

int *a, *b;

a, b are both integer pointers

int*

a, b;

a is integer pointer, b is just integer!

I dont like this!

typedefine int MyInt; MyInt k;

int k;

typedefine int* IntPt; IntPt a, b;

Recommended!!!

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++.

Pointer vs. Reference

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; //valid p = &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;

 A reference variable is different from a pointer

int x=10; int* ref; Ref = &x;
x ref

int x=10;

int& ref;
int& ref = x;
x ref

10

10

Traditional Pointer Usage

void 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.

a[0] a[1] a[2] a[3] a[4]

2 4 6

8
22

Dereference of an array name

a[0] a[1] a[2] a[3] a[4]

2 4 6

8
22

#include <iostream> Using namespace std; void main(){ int a[5] = {2,4,6,8,22}; cout << *a << " " << a[0] << " " << *(&a[0]); ..." } //main

Result is: 2 2 2

This element is called a[0] or *a

Array name as pointer

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; 2 cout << a[i] << " " << *p; 2 ... }

a a[0] a[1] a[2] a[3] a[4]

p 2 4 6 8 22

dynamic objects

Summary
Static variables (objects) Dynamic variables (objects)

A (direct) named memory location

int a; a = 20;

A static part (pointer) + (indirect) nameless memory location (dynamic part)

int* pa; pa = new int; *pa = 20;

20 static

pa static

20 dynamic

Simple dynamic variable

Dynamic array

int* p = new int; *p = 10; delete p;

int* p = new int[100]; for (i=1;i<100;i++) p[i] = 10; delete[] p;

p 10 10 10

10

delete two actions: 1. Return the object pointed to 2. Point the pointer p to NULL

delete p is not sufficient for an array!!!