Telerik JavaScript Framework Telerik Software Academy Hybrid Mobile Applications.
References vs. Pointers, Addresses, Pointer Arithmetic, Pointers & Arrays, Stack & Heap memory...
-
Upload
wendy-juliana-lee -
Category
Documents
-
view
248 -
download
1
Transcript of References vs. Pointers, Addresses, Pointer Arithmetic, Pointers & Arrays, Stack & Heap 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 Contents
1. References and their Applications
2. Pointers and Memory
3. Working with Pointers
Referencing & Dereferencing
Pointer arithmetic
4. Pointers vs. References
5. Pointers and Arrays
6. C++ Memory and Storage Types
7. Working with Dynamic and Static Memory
2
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 0x15A0
Value '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, PhoneGap
free C# book, безплатна книга C#, книга Java, книга C#Дончо Минков - сайт за програмиранеНиколай Костов - блог за програмиранеC# курс, програмиране, безплатно
?
? ? ??
?? ?
?
?
?
??
?
?
? ?
Questions?
?
References, Pointers and Memory
http://algoacademy.telerik.com