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!!!
