References, Pointers and

MemoryReferences vs. Pointers,

Addresses, Pointer Arithmetic, Pointers & Arrays, Stack & Heap memory

Learning & Development Teamhttp://academy.telerik.com

Telerik Software Academy

Table of Contents1. References and their Applications2. Pointers and Memory3. Working with Pointers

Referencing & Dereferencing Pointer arithmetic

4. Pointers vs. References5. Pointers and Arrays6. C++ Memory and Storage Types7. Working with Dynamic and Static

Memory2

ReferencesVariables aliases, Passing references

to functions

References A variable indicates a chunk of memory Computer perceives the variable as

that chunk References are aliases of variables

Same type, same memory, different name

i.e., indicate same chunk of memory as the variable

A reference only represents one variable Through its lifetime Must be initialized immediately (on

declaration)

References Syntax for defining a reference to a

variable

Reference points to same memory as its variable: Its value is the value

of the variable Assigning the reference a

value will actually assign the variable a value

int v = 5;int &r = v;cout<<r<<endl; //prints 5v = 6;cout<<r<<endl; //prints 6r = 4;cout<<v<<endl; //prints 4cout<<r<<endl; //prints 4

int &r = someVar; //reference to variable named //someVar (already existing)

'&' denotes

a referenc

e

Initialization is

obligatory

Reference BasicsLive Demo

Usage of References References are most used with functions Enable the function to change

parameters Remove overhead from "sending"

parameters

int SomeFunction(int &parameterByReference, ...){ //...}

Usage of References Reference parameters to edit values The function accesses the variable,

not its copy Variable passed in call to function is

affected

void MakePositive(int &number){

if(number < 0){ //this affects the variable in the

callernumber = -number;

}}int main(){

int a = -5;MakePositive(a); //after this line, a is

5}

Usage of References References to avoid overhead

Normal parameters are copied Copying large objects can take too

much time Especially when this happens often

Almost no good reason to copy parameters Any operation done on a copy can be

done on a reference – with the same effect (when reading)

Sending by reference doesn't copy the object, just its reference (which is fast)

Usage of References Example of fast and slow way of sending parameters to a function

Note: this is valid for potentially large objects (a vector can have many elements). Sending primitive types (int, char…) by copy and by reference is almost the same in speed

int GetSum(vector<int> &nums) //fast – only reference is sent{

int sum = 0int size =

nums.size();for(int i=0; i<size;

i++){

sum += nums[i];}return sum;

}

int GetSum(vector<int> nums) //overhead – elements copied{

int sum = 0int size =

nums.size();for(int i=0;

i<size; i++){

sum += nums[i];

}return sum;

}

Usage of References Reference parameters can be a problem OK to send reference instead of the

whole data But does the function read or edit

the data? You can't be sure, especially if you're

using 3rd party code const references solve this problem

Usage of References const references

Work the same way, but data can only be read

A normal reference can be assigned to a const one

A const reference cannot be assigned to a normal one i.e. a function cannot make a writeable

reference from a const one

int GetSum(const vector<int> &nums){ //this function can't edit nums

int sum = 0int size = nums.size();for(int i=0; i<size; i++){

sum += nums[i];}return sum;

}

Using ReferencesLive Demo

Pointers and MemoryRepresenting data in bytes, Variable

addresses, Stack and Dynamic Memory

Memory Computers work on data, stored in variables

Variables a program has at a given time are in the Random Access Memory (RAM) RAM is just an array of bytes

(software POV) Each byte in RAM has an address

(e.g. 0x000013A1)

Its index in the array, usually as a hex number

Information is described by address and value of the byte(s) at that address

Memory Early computing days

Programming was moving and editing bytes

From one address to another No "abstract" operations such as +,

-, *, / The programmer writes everything

from scratch Today, low-level memory is handled through: Data types Predefined operations (often on

hardware level) E.g. assigning values is copying

memory

Variables in Memory Most data types occupy more than one byte Occupied bytes are sequential E.g. data for a 4-byte int starting at 0x000013A3, also occupies 0x000013A4, 0x000013A5 and 0x000013A6

Address of a variable The address of its first byte The program can access the next

bytes By knowing the size of the data type

Variables in Memory Example of a 4-byte integer in memory at address 0x13A3, with a value of 624 in a Big-endian system

i.e. most-significant byte is leftmost address

Address 0x13A2

0x13A3 0x13A4 0x13A5 0x13A6 0x13A7

Data … 00000000 00000000 00000010 01110000 …

int x = 624;

int x = 624;cout<<&x<<endl; //outputs 0x13A3 //(in the described case)//&x reads as "the address of x"//not the same as reference variables,//returns address of the first byte of x

Memory Pointers Pointer – special variable, associated with an address in memory Holds the memory address of

another variable "Points" to another variable Can point to any byte in memory Special "null" (0) value – shows the

pointer currently holds no variable's address

Two essential operations for using pointers Referencing Dereferencing

Memory Pointers Referencing – getting a variable's address Variable's address (as a number) is

returned from the variable's identifier

i.e. gets the value of a pointer to the variable

Address 0x13A2

0x13A3 0x13A4 0x13A5 0x13A6 0x13A7

Data … 00000000 00000000 00000010 01110000 …

int x = 624;

Here, referencing x gives 0x13A3 (5027 decimal)Let p be a pointer to xThen, the value of p is 0x13A3 (5027 in decimal)

Memory Pointers Dereferencing – getting value from an address The variable (the memory data) is

returned from a pointer to that variable

i.e. accesses memory at the address, pointed by the pointer

* Note: we need to know the data type to dereference

Address 0x13A2

0x13A3 0x13A4 0x13A5 0x13A6 0x13A7

Data … 00000000 00000000 00000010 01110000 …

p is a pointer to address 0x13A3

Let us dereference p as a 4-byte integer* xThe data for x is in bytes 0x13A3 to 0x13A6Then the value of x is 624

Pointers and Memory Pointers – the common way to access memory

Most programming languages use pointers Some allow full access (like C and

C++) Some hide pointers objects (C#, JS)

Reference and Dereference operators respectively create and evaluate pointers

Usually pointers can be incremented/decremented i.e. "moved" to neighboring

addresses

Working with Pointers in C++The & and * operators, Pointer values and arithmetic,

const pointers, Building pointers from addresses

Working with Pointers in C++

C++ provides lots of functionality for working with pointers Assigning pointers to variables and

dereferencing Pointer types – int, char, string, etc. Basic memory pointers – a.k.a. void

pointers Assigning pointers to arbitrary

memory addresses Incrementing/Decrementing

pointers Casting pointers from one type to

another

Pointers in C++ – Creating

Declaring and assigning pointers C++ pointers have types and are

declared as normal variables A * (asterisk) sign prefix of the

variable name denotes a pointer Typically, assigning values requires

a variable's address – which is returned by the & operatorint v = 5;int *vPtr;vPtr = &v; //get the address (pointer to) vcout<<vPtr<<endl; //prints hex address of v

Pointers in C++ – Dereferencing

Getting values from pointers C++ pointers have types

Dereferencing accesses memory as Dereferencing is done through the *

(asterisk) operator, as a prefix to an existing pointer This gives direct read/write access to

the memory Note: * is used for declaration and

dereferencing

int v = 5;int *vPtr = &v; //here, * means create a pointer(*vPtr)++; //here, * means access the pointed memorycout<<*vPtr<<endl; //prints 6

Pointer BasicsLive Demo

Pointer Arithmetics Arithmetic operations on pointers

"Move" a pointer to a neighboring memory cell

Addresses are just numbers Moving from one address to the

next means incrementing/decrementing the pointer

Allowed arithmetic operations on pointers Addition Subtraction i.e. move a pointer 1, 2, 3, etc…

positions

Pointer Arithmetics Pointer arithmetics work in different ways For different pointer types E.g. incrementing int* and char*

usually works differently Increment/Decrement depend on data type More precisely, the size of the data

type Incrementing a pointer of type T by 1 means incrementing the address to which it points to by 1 multiplied by sizeof(T)

Decrementing is analogous

Pointer Arithmetics Example of pointer arithmetics

Suppose the current system uses 1 byte for char, 2 bytes for short and 4 bytes for intchar *charPtr = ...//memory address 0x13A0short *shortPtr = ...//memory address 0x14A0int *intPtr = ...//memory address 0x15A0

charPtr++; shortPtr++; intPtr++;

cout<<charPtr<<", "<<shortPtr<<", "<<intPtr<<endl;//prints 0x13A1, 0x14A2, 0x15A4

Pointer Arithmetics Example explanation

0x13A0 0x13A1 0x13A2 0x13A3 0x13A4

0x14A0 0x14A1 0x14A2 0x14A3 0x14A4

0x15A0 0x15A1 0x15A2 0x15A3 0x15A4

charPtr is 0x13A0, sizeof(char) is 1, 0x13A0 + 1 = 0x13A1

shortPtr is 0x14A0,sizeof(short) is 2, 0x14A0 + 2 = 0x14A2

intPtr is 0x15A0,sizeof(int) is 4, 0x15A0 + 4 = 0x15A4

charPtr

shortPtr

intPtr

0x13A0 + sizeof(char)

0x14A0 + sizeof(short)

0x15A0 + sizeof(int)

Pointer ArithmeticsLive Demo

Pointer Arithmetics A pointer can be incremented/decremented with any value (not just using ++ and --)

The expression p = p + 3 is valid Where p is a pointer Same rule for increasing by a

multiple of type size is enforced E.g. if p is an int pointer to address 0x15A0 after the expression is evaluated p

points 0x15AC The same rules apply for subtraction

Pointers and const As with references,

values pointed by pointers can be marked const

Unlike references, pointers can change to what they

point Two pointer characteristics that can

be const Meaning a total of 4 pointer

variations

Pointers and const Non-constant pointer to non-constant variable Pointed memory can be modified by

pointer Pointed address can be changed

This is the "normal" pointer, from previous examples

int x = 5; int *xPtr = &x; xPtr++; xPtr--; (*xPtr) = 4;int *otherXPtr = xPtr; //all operations valid

Pointers and const Non-constant pointerto constant variable Pointed memory cannot be modified

by pointer Pointed address can be changedint x = 5;

const int *xPtr = &x;xPtr++; xPtr--; (*xPtr) = 4; //error: read-only memoryint *otherXPtr = xPtr; //error: invalid conversion

Pointers and const Constant pointerto non-constant variable Pointed memory can be modified by

pointer Pointed address cannot be changedint x = 5;

int * const xPtr = &x;xPtr++; //error: read-only pointerxPtr--; //error: read-only pointer(*xPtr) = 4;int *otherXPtr = xPtr;

cout<<x<<endl;

Pointers and const Constant pointerto constant variable Pointed memory cannot be modified

by pointer Pointed address cannot be changedint x = 5;

const int * const xPtr = &x;xPtr++; ///error: read-only pointerxPtr--; ///error: read-only pointer(*xPtr) = 4; ///error: read-only memoryint *otherXPtr = xPtr; ///error: invalid conversion

cout<<x<<endl;

Pointers and const Pointers are useful as function parameters

Non-const pointers to non-const variables Passing data to the function for

modification Traversing and modifying memory

(arrays) Non-const pointers to const variables Efficiently passing large data to a

function Protecting the data from

modification Much like const references, so most

compilers implement const references this way

Pointers and const const pointers in general

Useful for storing specific memory locations And using them directly, i.e. no

casting Especially when working with:

Hardware expecting input at a specific address (i.e. you use const pointer to non-const memory)

Hardware producing output at a specific address (i.e. you use const pointer to const memory)

Pointers and constLive Demo

Pointers to Pointers in C++

Pointers are just numbers and have addresses

So you can have pointers to pointers Each pointer "level" is called an

indirection E.g., a pointer to a pointer is a

double indirection At declaration, one * per each

indirection

char x = 'a';char * xPtr = &x;char ** xPtrPtr = &xPtr;

Address 0x13A0 0x14A0 0x15A0Value 'a' 0x13A0 0x14A0

x * xPtr ** xPtrPtr

Pointers to Pointers in C++

Pointers to pointers have many applications Multidimensional arrays, composite

objects, … Modifying pointer address by

functions i.e. modify where the pointer points,

not the data

void MovePtrToNextZero(int ** pointerAddress){ int value = **pointerAddress; while(value != 0) { (*pointerAddress)++; value = **pointerAddress; }} //Note: an often better (not always applicable) approach //is to return a new pointer, not modify the parameter

Pointers to PointersLive Demo

Pointer to Specific Memory

C++ allows creating pointers to specific memory addresses

E.g. you can make a pointer point to 0x13A0 Regardless of whether or not the

program is allowed to access that memory

Accessing the memory could trigger an access violation (error code 0xC0000005)

Avoid creating pointers in such a way Very unsafe and error-prone Necessary in some cases (low-level

code)

Pointer to Specific Memory

Initialize pointer to specific memory address Simply provide the address as a

number Hex is the convention, but not

obligatory And cast it to the desired pointer

type Some argue cast should be reinterpret_cast reinterpret_cast forces cast

(regardless of type) Also sort of says "Here be dragons!"

int *ptr = (int*)5024;int *otherPtr = reinterpret_cast<int*>(0x13A0);cout << (ptr==otherPtr) << endl; //prints 1cout << ptr << endl; //prints 0x13A0

Pointers in C++ – Void Pointers

Void pointers are a special type of pointer Not associated with a data type Can point to any variable/byte of

memory Useful as a "universal pointer"

Cannot do pointer arithmetic Cannot modify memory or be

dereferenced Void pointers are useful after casted

int a = 5; char b = 'x'; void *p;p = &a; p = &b;cout << *((char*)p) << endl; //prints 'x'

C++ Function Pointers Function pointers are special pointers Similar restrictions as void pointers Typically used to pass functions as

parameters Declaration and calling are similar

to normal function declaration and calling With brackets around function name * before function name, inside the

brackets

#include <cmath>...double (*squareRootPtr)(double) = sqrt;cout << (*squareRootPtr)(9) << endl; //prints 3

Function PointersLive Demo

Pointers vs. ReferencesMain Differences, Advantages and

Disadvantages

References vs. Pointers Pointers are generally more versatile Exist before references (pure C) A lot of functionality and various

types Low(est)-level memory access Base for polymorphism in C++ OOP Harder to read, require a lot of

operators Relatively unsafe and error prone

References vs. Pointers References are generally tidier and safer High level – act as variables, not

addresses No special operators except at

declaration Easy to initialize, work with and read

Memory-safe, hard to access wrong memory

Cannot fully replace pointers Useful only for sending parameters

to functions

Pointers vs. References References can point to only 1 variable Through their lifetime

References cannot be NULL References must be initialized on declaration

The address of a reference cannot be obtained The & operator returns the

variable's address i.e. can't have pointer to reference

or reference to reference

Pointers vs. References Pointer arithmetics don't work on references

You can't make an array of references

It is a bad practice to return a reference It's usually ok to return a pointer

References usually implemented as const pointers in compilers Although the standard doesn't

dictate this

Pointers and ArraysArrays in Memory, Pointers and the []

Operator, Substituting Arrays with Pointers

Pointers and Arrays In memory, arrays are sequences of variables Which are sequences of bytes i.e. an array is not fragmented in

memory A series of bytes, with a length of

number of items * item type size E.g.

on a system where sizeof(short) is 2, an array of 3 shorts, occupies a block of 6 bytes

0x13A2 0x13A3 0x13A4 0x13A5 0x13A6 0x13A7

short

short

short

Pointers and Arrays The address of an array

Is the same as the address of its first element

Arrays also keep other information like Array size, dimension size, etc.

Arrays often "degenerate" into pointers Most array operations can be done

with pointers Arrays can't change the memory they point to Same as a const pointer

Pointers and Arrays The most important array "operator" – [] Is actually a syntax shorthand Translates to pointer arithmetic

Addition is commutative, even for pointers:arrPtr + 3 == 3 + arrPtr == arr[3] == 3[arr](where int *arrPtr = arr)

int arr[5] {1, 2, 3, 4, 5};

int * arrPtr = arr; //We could also do the //operations below with arr//Тhe following lines print the samecout<<arr[3]<<" at "<<&arr[3]<<endl;cout<<3[arr]<<" at "<<&3[arr]<<endl;cout<<*(arrPtr + 3)<<" at "<<(arrPtr + 3)<<endl;

Pointers and Arrays The operator [] can be used with any pointer Does additive pointer arithmetic Dereferences the result i.e. adds number in brackets with

the pointer Return value – the dereferenced

result pointer A pointer can be used to

Traverse, assign and read array-like memory

Represent an array as a function parameter

Pointers essential in using dynamic memory

Pointers and ArraysLive Demo

Memory and Storage Types"Stack" and "Heap" Memory, Storage

Durations – automatic and dynamic

Memory and Storage Types

Programs usually use 2 types of memory Stack memory Heap memory

Stack memory Separate for each process/thread Stores function-local data,

addresses, etc. Automatically freed when out of

scope Heap memory

Manual, dynamic alloc/dealloc, usually larger

Memory and Storage Types

C++ utilizes stack and heap memory through Automatic storage – mapped to the

stack Dynamic storage – works on the

heap Some ways of dynamic storage on

the stack exist(mostly non-standard)

Storage types define how memory is managed When/where memory for variables

is allocated What defines memory deallocation

Memory and Storage Types

C++ automatic storage – typical variables Variables local to functions Function parameters Basically all variable-related

memory Pointers too – the address number,

not the data C++ dynamic storage

Memory allocated with operator new (C++03) C++11 also offers Smart Pointers

Memory addresses are assigned to pointers

Memory and Storage Types

Notes on automatic storage Should be used for small data

Size known compile-time Short lived – out of scope means

deleted Faster than dynamic Freed upon function end. Don't

return reference Ok to pass as a parameter by

reference/pointer Bad to return by reference/pointer Returned pointer/reference will point

to deallocated (freed) memory

Memory and Storage Types

Notes on dynamic storage Useful when needed memory is not

known compile-time Always accessed through pointers Very agile for passing around the

entire program's scope & lifespan Manual allocation and deallocation

E.g. the operators new and delete Dynamic memory is shared, i.e. if

you allocate all of it, other processes can't allocate

Working with Automatic and

Dynamic Storage in C++Initializing Automatic Variables,

Allocating and Deallocating Dynamic Memory

Automatic & Dynamic in C++

Automatic storage Variables you declare in functions Including references and pointers

as "numbers" i.e. addresses, not pointed memory

Arrays with size in declaration Compile-time known size arrays

auto keyword Explicitly denote automatic storage

until C++11 C++ 11 changes the meaning (old

meaning wasn't really needed)

Automatic StorageLive Demo

Automatic & Dynamic in C++

Dynamic storage – memory allocated manually Through operators like new Through functions like malloc Through C++11 Smart Pointers Deallocated manually

If not deallocated can lead to a "memory leak"

Memory is released by code, not automatically

Accessed through pointers

Automatic & Dynamic in C++

Using the new operator Initialization of a single instance of

a type new as prefix, type constructor

Initialization of multiple instances of a type i.e. array of objects of the type new as prefix, typename, brackets

with a number

Note: heapInt and heapArray are automatic, but the pointed memory is dynamic and will not be deallocated automatically

int *heapInt = new int();//value 0

int *heapArray = new int[5];//array of 5 random ints

Automatic & Dynamic in C++

Using the delete operator Frees up memory allocated with new Freeing up a single instance of a

type delete followed by pointer to the

memory

Freeing up multiple instances (arrays) of a type delete, brackets, pointer to memory

Note: if you lose all the pointers to the memory (they go out of scope), you can't deallocate it (unless you know its address)

delete heapInt;

delete[] heapArr;

Dynamic StorageLive Demo

Summary References are just aliases of variables Can only represent one variable;

can be const Pointers provide low level memory access Can point to any memory

address/variable Can represent contiguous memory

as arrays Can move through memory

(arithmetic) We saw dynamic and automatic memory Dynamic memory implies new and delete

Local variables are automatic

форум програмиране, форум уеб дизайнкурсове и уроци по програмиране, уеб дизайн – безплатно

програмиране за деца – безплатни курсове и уроцибезплатен SEO курс - оптимизация за търсачки

уроци по уеб дизайн, HTML, CSS, JavaScript, Photoshop

уроци по програмиране и уеб дизайн за ученициASP.NET MVC курс – HTML, SQL, C#, .NET, ASP.NET MVC

безплатен курс "Разработка на софтуер в cloud среда"

BG Coder - онлайн състезателна система - online judge

курсове и уроци по програмиране, книги – безплатно от Наков

безплатен курс "Качествен програмен код"

алго академия – състезателно програмиране, състезанияASP.NET курс - уеб програмиране, бази данни, C#, .NET, ASP.NET

курсове и уроци по програмиране – Телерик академия

курс мобилни приложения с iPhone, Android, WP7, PhoneGapfree C# book, безплатна книга C#, книга Java, книга C# Дончо Минков - сайт за програмиране

Николай Костов - блог за програмиранеC# курс, програмиране, безплатно

?? ? ?

??? ?

?

? ?

??

?

?

? ?

Questions?

?

References, Pointers and Memory

http://algoacademy.telerik.com