Scribd
Upload
64 views

Review On Pointers and Dynamic Objects

The document discusses pointers and dynamic objects in C++. It explains that static memory is allocated at compile time while dynamic memory is allocated at runtime. Dynamic objects are implemented using pointers, which store the address of memory cells. A pointer can be used to reference the memory cell it points to. The asterisk operator is used to dereference a pointer and access the value at its address. Pointers allow objects to exist beyond the scope they were allocated in. References are similar to pointers but always refer to the same object, unlike pointers which can be reassigned. Arrays names act as pointers to the first element. Dynamic objects are allocated using new and deleted using delete.

Uploaded by

shrutipiet1
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
64 views

Review On Pointers and Dynamic Objects

The document discusses pointers and dynamic objects in C++. It explains that static memory is allocated at compile time while dynamic memory is allocated at runtime. Dynamic objects are implemented using pointers, which store the address of memory cells. A pointer can be used to reference the memory cell it points to. The asterisk operator is used to dereference a pointer and access the value at its address. Pointers allow objects to exist beyond the scope they were allocated in. References are similar to pointers but always refer to the same object, unlike pointers which can be reassigned. Arrays names act as pointers to the first element. Dynamic objects are allocated using new and deleted using delete.

Uploaded by

shrutipiet1
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 23

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

You might also like