Download - References, Pointers and Memory
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 ¶meterByReference, ...){ //...}
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