Procedural Concept

• The main program coordinates calls to

procedures and hands over appropriate data
as parameters. 1
 Object-Oriented Concept

• Objects of the program interact by sending messages to

each other
2
 C++
• Supports Data Abstraction
• Supports OOP
– Encapsulation
– Inheritance
– Polymorphism
• Supports Generic Programming
– Containers
• Stack of char, int, double etc
– Generic Algorithms
• sort(), copy(), search() any container Stack/Vector/List

3
 Pointers, Dynamic Data, and
Reference Types
• Review on Pointers
• Reference Variables
• Dynamic Memory Allocation
– The new operator
– The delete operator
– Dynamic Memory Allocation for Arrays

4
 C++ Data Types

simple structured

integral enum floating array struct union class

char short int long bool

float double long double address

pointer reference
5
char str [ 8 ];

• str is the base address of the array.

• We say str is a pointer because its value is an address.
• It is a pointer constant because the value of str itself
cannot be changed by assignment. It “points” to the
memory location of a char.

6000

‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’

str [0] [1] [2] [3] [4] [5] [6] [7]

6
 Addresses in Memory
• When a variable is declared, enough memory to hold a
value of that type is allocated for it at an unused memory
location. This is the address of the variable

int x;
float number;
char ch;

2000 2002 2006

x number ch
7
 Obtaining Memory Addresses
• The address of a non-array variable can be obtained by using
the address-of operator &

2000 2002 2006

int x;
float number;
x number ch
char ch;

cout << “Address of x is “ << &x << endl;

cout << “Address of number is “ << &number << endl;

cout << “Address of ch is “ << &ch << endl;

8
 What is a pointer variable?

• A pointer variable is a variable whose value is the address of a

location in memory.
• To declare a pointer variable, you must specify the type of
value that the pointer will point to, for example,

int* ptr; // ptr will hold the address of an int

char* q; // q will hold the address of a char

9
 Using a Pointer Variable
2000
int x;
12
x = 12;
x

3000
int* ptr;
2000
ptr = &x;
ptr

NOTE: Because ptr holds the address of x,

we say that ptr “points to” x
10
 *: dereference operator
2000
int x;
12
x = 12;
x

3000
int* ptr;
2000
ptr = &x; ptr

cout << *ptr;

NOTE: The value pointed to by ptr is denoted by *ptr

11
Using the Dereference Operator
2000
int x;
12 5
x = 12;
x

3000
int* ptr;
2000
ptr = &x; ptr

*ptr = 5;
// changes the value at the
address ptr points to 5
12
 Self –Test on Pointers
4000
char ch;
A Z
ch = ‘A’;
ch

char* q; 5000 6000

q = &ch; 4000 4000

q p
*q = ‘Z’;
char* p;
p = q; // the rhs has value 4000

// now p and q both point to13ch

 Using a Pointer to Access the
Elements of a String
char msg[ ] =“Hello”;
msg
char* ptr; 3000

ptr = msg; ‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’

‘M’ ‘a’
*ptr = ‘M’ ;
ptr++;
*ptr = ‘a’; 3000
3001

ptr

14
 Reference Variables
Reference variable = alias for another variable
- Contains the address of a variable (like a pointer)
- No need to perform any dereferencing (unlike a pointer)
- Must be initialized when it is declared

int x = 5;
int &z = x; // z is another name for x
int &y ; //Error: reference must be initialized
cout << x << endl; -> prints 5
cout << z << endl; -> prints 5

z = 9; // same as x = 9;

cout << x << endl; -> prints 9

cout << z << endl; -> prints 9
15
 Why Reference Variables
• Are primarily used as function parameters

• Advantages of using references:

– you don’t have to pass the address of a variable
– you don’t have to dereference the variable inside the
called function

16
 Reference Variables Example
#include <iostream.h>
void p_swap(int *a, int *b)
{
// Function prototypes
(required in C++) int temp;
temp = *a; (2)
*a = *b; (3)
void p_swap(int *, int *);
*b = temp;
void r_swap(int&, int&);
}
int main (void){
void r_swap(int &a, int &b)
int v = 5, x = 10;
{
cout << v << x << endl;
int temp;
p_swap(&v,&x); temp = a; (2)
cout << v << x << endl; a = b; (3)
r_swap(v,x); b = temp;
cout << v << x << endl; }
return 0;
17
}
 Dynamic Memory Allocation
In C and C++, three types of memory are used by programs:

• Static memory - where global

and static variables live

• Heap memory - dynamically

allocated at execution time
- "managed" memory accessed
using pointers

• Stack memory - used by

automatic variables

18
 3 Kinds of Program Data
• STATIC DATA: Allocated at compiler time

• DYNAMIC DATA: explicitly allocated and

deallocated during program execution by C++
instructions written by programmer using operators
new and delete
• AUTOMATIC DATA: automatically created at
function entry, resides in activation frame of the
function, and is destroyed when returning from
function
19
Dynamic Memory Allocation Diagram
H ig h -e n d

R u n -tim e a llo c a te d
S ta c k

m e m o ry
H eap

C o m p ile -tim e
s ta tic d a ta

a llo c a te d
m e m o ry
P ro g ra m
code

L o w -e n d

20
 Dynamic Memory Allocation
• In C, functions such as malloc() are used to
dynamically allocate memory from the Heap.
• In C++, this is accomplished using the new and
delete operators
• new is used to allocate memory during execution time
– returns a pointer to the address where the object is
to be stored
– always returns a pointer to the type that follows the
new
21
 Operator new Syntax

new DataType

new DataType [IntExpression]

• If memory is available, in an area called the heap (or free

store) new allocates the requested object or array, and
returns a pointer to (address of ) the memory allocated.
• Otherwise, program terminates with error message.
• The dynamically allocated object exists until the delete
operator destroys it.
22
 Operator new
2000
char* ptr; ???
5000

ptr
ptr = new char;
5000
*ptr = ‘B’;
‘B’
cout << *ptr;

NOTE: Dynamic data has no variable name

23
 The NULL Pointer
• There is a pointer constant called the “null pointer”
denoted by NULL
• But NULL is not memory address 0.

• NOTE: It is an error to dereference a pointer whose

value is NULL. Such an error may cause your
program to crash, or behave erratically. It is the
programmer’s job to check for this.

while (ptr != NULL) {

. . . // ok to use *ptr here
} 24
 Operator delete Syntax

delete Pointer

delete [ ] Pointer

• The object or array currently pointed to by Pointer is

deallocated, and the value of Pointer is undefined. The
memory is returned to the free store.
• Good idea to set the pointer to the released
memory to NULL
• Square brackets are used with delete to deallocate a
dynamically allocated array.
25
 Operator delete
2000
char* ptr;
5000
???

ptr = new char; ptr

*ptr = ‘B’;
5000
cout << *ptr;
‘B’
delete ptr; NOTE:
delete deallocates the
memory pointed to by ptr

26
 Example
char *ptr ;
3000
ptr
ptr = new char[ 5 ]; 6000
NULL
???
???

strcpy( ptr, “Bye” );

6000
ptr[ 0 ] = ‘u’;
‘B’ ‘y’ ‘e’ ‘\0’
‘u’
delete [] ptr; // deallocates the array pointed to by ptr
// ptr itself is not deallocated
ptr = NULL; // the value of ptr becomes undefined

27
 Pointers and Constants
char* p;
p = new char[20];

char c[] = “Hello”;

const char* pc = c; //pointer to a constant
pc[2] = ‘a’; // error
pc = p;

char *const cp = c; //constant pointer

cp[2] = ‘a’;
cp = p; // error

const char *const cpc = c; //constant pointer to a const

cpc[2] = ‘a’; //error
cpc = p; //error
28
 Take Home Message
• Be aware of where a pointer points to, and
what is the size of that space.

• Have the same information in mind when

you use reference variables.

• Always check if a pointer points to NULL

before accessing it.
29