spl – practical session 2
DESCRIPTION
SPL – Practical Session 2. Topics: C++ Memory Management Pointers. C++ Memory Handling. Memory Model, Pointers. Variables in C++ Memory System. There are two "kinds" of memory available to a process: Stack: Stores local variables of the function. Removed once the function ends! Heap: - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/1.jpg)
SPL – Practical Session 2
• Topics:– C++ Memory Management– Pointers
![Page 2: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/2.jpg)
C++ Memory Handling
Memory Model, Pointers
![Page 3: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/3.jpg)
Variables in C++ Memory System
There are two "kinds" of memory available to a process:•Stack:– Stores local variables of the function.– Removed once the function ends!
•Heap:– Contains dynamically allocated variables. – Stays once the function ends, unless cleared before!
Read more: http://www.learncpp.com/cpp-tutorial/79-the-stack-and-the-heap/
![Page 4: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/4.jpg)
Pointers• A pointer is a variable that holds the address of some other variable.• In Java, you can’t directly access the memory of such object! Only by
reference.• In C++, you can access them directly! Alter them any way you like, without any
limitations!Benefit: More control than Java.Drawback: Memory leaks, Memory corruption.
• A 64-bit computer can address 264 bytes! • Each memory cell is 1 byte. (byte-accessible machines – most of the machines
today)• Each pointer takes a static size of 4 bytes in a 32bit OS, and 8bytes in a 64bit
OS.• Pointers themselves are saved on the stack.
![Page 5: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/5.jpg)
Java vs. C++
Java’s References• String s = new String("a string");
– The value of the variable 's' is the location of the object on the heap, but we don’t have access to this value!
• You can not have a variable that 'points' to a primitive type
• String s = null;– means "I don't have the
address of any meaningful data"
C++ Pointers
• Have access to actual memory locations.
• Can point to anything!
• The null value in C++ is the number 0 (memory address 0).
![Page 6: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/6.jpg)
Pointers – Bit Level• Declaration: int x= 5– int *ptr1 = &x; • integers are of size 4bytes, which means:
x:
– Char c = ‘z’; char *ptr2 = &c; (‘z’ equals to 122)• Char takes 1byte of memory:
c:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 1 1 1 1 0 1 0
ptr1
ptr2
Decimal to binary conversion: http://www.wikihow.com/Convert-from-Decimal-to-Binary
ASCII table: http://www.asciitable.com/
![Page 7: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/7.jpg)
Pointers
...
...
MEMORY ADDRESS SPACE
100010011002100310041005
1006
81344813458134681347
Addressint x;int *foo;
x= 123;
foo = &x;
foo
x
0
foo contains the address it points at.*foo is the value that foo points at.&x is the address of variable x.&foo is the address of the pointer foo.
1 2 3
![Page 8: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/8.jpg)
Comparing Pointers• int j = 5; • int i = 5;• int *ptrj1 = &j; • int *ptrj2 = &j; • int *ptri = &i;
• True/False:• if (ptrj1 == ptrj2) ? • if (ptrj1 == ptri) ?• if (&ptrj1 == &ptrj2) ?• if (*ptrj1 == *ptri) ?
True
False
False
True
![Page 9: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/9.jpg)
Assigning a value to a dereferenced pointer
A pointer must have a value before you can dereference it (follow the pointer).
int *x;*x=3;
int foo;int *x;x = &foo;*x=3;ERROR!
Overrode the value located
in some address!
this is fine
x points to foo
![Page 10: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/10.jpg)
Pointers to pointers
int *x;
int **y;
double *z;
x some int
some *int some inty
z some double
![Page 11: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/11.jpg)
Pointers to pointers• Example:– int i = 5; – int *p_i = &i;– int **pp_i = &p_i;
• Then:pp_i is memory location of …
p_i*pp_i is memory location of …
i**pp_i equals…
5
![Page 12: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/12.jpg)
Pointers and Arrays
• Array name is basically a const pointer pointing at the beginning of the array.
• You can use the [] operator with pointers!• Example:– int A[5];– Creates a memory block of 5 integers on the stack
(5x4bytes) where A (the pointer) points at the beginning of the array -> A[0]. (A = &A)A
![Page 13: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/13.jpg)
Pointers and Arrays
int *x;
int a[5]={-1,-2,-3,-4,-5};
x = &a[2];
for (int i=0;i<3;i++)
x[i]++;
x is “the address of a[2] ”
x[i] is the same as a[i+2]
-1 -2 -3 -4 -5
a
x[0]x[1] x[2]
x
![Page 14: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/14.jpg)
Pointer arithmetic• Integer math operations can be used with pointers: +, -, +
+, --, +=, -=• If you increment a pointer, it will be increased by the size
of whatever it points to.• Incrementing pointers will basically make it point to the
“next” element in memory.
int a[5];
a[0] a[1] a[2] a[3] a[4]
int *ptr = a;
*ptr
*(ptr+2)*(ptr+4)
![Page 15: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/15.jpg)
C++ char*
'R‘
msg null
'P‘ 'I‘ \0
strlen(msg) == 3;
![Page 16: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/16.jpg)
Using the Heap• All primitives are stored in the stack, • All that is made without new command is stored in the stack. (except global variables and initailized char* –
splab!)• Using the new keyword, we can now allocate memory on the heap.
– int *i = new int;– string *str = new string(“hi there, heap is cozy!”);– int *arr = new int[5];
• Deleting these objects can be done by using the delete keyword.
– delete i;– delete str;– delete[] arr;
Safe Delete:
if (0 != p){ delete p; p=0; }
DO NOT DELETE A PONTER NOT ALLOCATED BY NEW
![Page 17: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/17.jpg)
Pointer Pitfalls
• Assigning values to uninitialized, null, or deleted pointers: int *p; int *p = NULL; int *p = new int; *p = 3; *p = 4; delete p;
*p = 5;
All of these cases end up with segmentation fault!
![Page 18: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/18.jpg)
Dangling Pointer
• A pointer that points at nothing:• Example:
int *p, *q; p = new int; q = p; delete q;*p = 3; //illegal assignment!
•p and q point to the same location, q is deleted, results with p becoming a dangling pointer!
![Page 19: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/19.jpg)
Memory Leaks
• Memory leak is when you remove the reference to the memory block, before deleting the block itself. Example:
int *p = new int; p = NULL;//or a new other value
p points at memory location of type int.p changed to point at null.Result? Must free memory block before changing reference.
Memory leak!
![Page 20: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/20.jpg)
• A memory leak can diminish the performance of the computer by reducing the amount of available memory.
• Eventually, in the worst case, too much of the available memory may become allocated
• and all or part of the system or devices stops working correctly, the application fails, or the system slows down.
Use valgrind with –leak-check=yes option if your implementation has memory leaks.Valgrind User Manual, The Valgrind Quick Start Guide, Graphical User Interfaces
* This is why the –g flag is used when debugging!
![Page 21: SPL – Practical Session 2](https://reader035.vdocuments.net/reader035/viewer/2022062802/56814471550346895db1045e/html5/thumbnails/21.jpg)
• DO NOT FORGET TO SUBMIT:– Homework0– Homework1– Homework2The Targilonim help your exercise the things we
learnt so far!
• READ COURSE ANNOUNCEMETNS!• Presentations: www.cs.bgu.ac.il/~jumanan
Before You Leave!