Ce diaporama a bien été signalé.
Le téléchargement de votre SlideShare est en cours. ×

SPL_PS2 (1).ppt

Publicité
Publicité
Publicité
Publicité
Publicité
Publicité
Publicité
Publicité
Publicité
Publicité
Publicité
Publicité
Prochain SlideShare
8329969.ppt
8329969.ppt
Chargement dans…3
×

Consultez-les par la suite

1 sur 21 Publicité
Publicité

Plus De Contenu Connexe

Plus récents (20)

Publicité

SPL_PS2 (1).ppt

  1. 1. SPL – Practical Session 2 • Topics: – C++ Memory Management – Pointers
  2. 2. C++ Memory Handling Memory Model, Pointers
  3. 3. 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/
  4. 4. 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.
  5. 5. 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).
  6. 6. 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/
  7. 7. Pointers ... ... MEMORY ADDRESS SPACE 1000 1001 1002 1003 1004 1005 1006 81344 81345 81346 81347 Address int 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.
  8. 8. 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
  9. 9. 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;
  10. 10. Pointers to pointers int *x; int **y; double *z; x some int some *int some int y z some double
  11. 11. 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
  12. 12. 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
  13. 13. 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
  14. 14. 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)
  15. 15. C++ char* • char* is another way to represent strings in C++. (it actually came first - with C!) • char* is an array of chars. • char* arrays are terminated with ‘0’ – “null terminated strings”. “denotes end of string”. • char *msg= “RPI”; • Length of string? 'R‘ msg 'P‘ 'I‘ 0 strlen(msg) == 3;
  16. 16. 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
  17. 17. 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!
  18. 18. 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!
  19. 19. 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!
  20. 20. • 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!
  21. 21. • DO NOT FORGET TO SUBMIT: – Homework0 – Homework1 – Homework2 The Targilonim help your exercise the things we learnt so far! • READ COURSE ANNOUNCEMETNS! • Presentations: www.cs.bgu.ac.il/~jumanan Before You Leave!

×