Chapter 15 Pointers, Dynamic Data, and Reference Types

1. Chapter 15Pointers, Dynamic Data, and Reference Types Dale/Weems/Headington

2. Chapter 15 Topics • Using the Address-Of Operator & • Declaring and Using Pointer Variables • Using the Indirection (Dereference) Operator * • The NULL Pointer • Using C++ Operators new and delete

3. 6000 ‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’ str [0] [1] [2] [3] [4] [5] [6] [7] Recordar que . . . char str [ 8 ]; stres el “base address” del arreglo. Decimos que str es un “pointer” debido a que su valor es una dirección (“address”). Es un “pointer” constante debido a que el valor de str por si mismo no puede ser cambiado por asignación. Esto debido a que apunta a la localización de memoria de un char.

4. Direcciones en Memoria Cuando una variable es declarada, se separa en memoria el espacio requerido de acuerdo a su tipo de dato. A la misma vez, se obtiene la dirección de cada variable. int x; float number; char ch; 2000 2002 2006 xnumberch

5. Obteniendo Direcciones de Memoria • La dirección de una variable que no sea un arreglo, puede ser obtenido usando el operador & int x; float number; char ch; cout << “Address of x is “ << &x << endl; cout << “Address of number is “ << &number << endl; cout << “Address of ch is “ << &ch << endl;

6. ¿Qué es una variable tipo pointer? • Es una variable cuyo valor es la dirección (“address”) de una localización de memoria. • Para declarar una variable tipo pointer, se debe indicar el tipo de dato al cual se va a apuntar, por ejemplo; int* ptr;// ptr will hold the address of an int char* q;// q will hold the address of a char

7. Utilizando una Variable tipo Pointer 2000 12 x 3000 2000 ptr int x; x = 12; int* ptr; ptr = &x; NOTA: Debido a que ptr tiene la dirección de x, decimos que ptr “apunta a” x

8. El operator unario * es un operador indirecto (“deferencia”) 2000 12 x 3000 2000 ptr int x; x = 12; int* ptr; ptr = &x; cout << *ptr; NOTA: El valor que apunta ptr se denota como *ptr

9. Utilizando el Operador de Deferencia 2000 12 5 x 3000 2000 ptr int x; x = 12; int* ptr; ptr = &x; *ptr = 5; // changes the value // at address ptr to 5

10. Otro Ejemplo 4000 A Z ch 5000 6000 4000 4000 q p char ch; ch = ‘A’; char* q; q = &ch; *q = ‘Z’; char* p; p = q; // the rhs has value 4000 // now p and q both point to ch

11. Utilizando un Pointer para aceder los Elementos de un String 3000 char msg[ ] = “Hello”; ‘M’ ‘a’ 3001 char* ptr; 3000 ptr = msg; // recall that msg == &msg[ 0 ] *ptr = ‘M’ ; ptr++; // increments the address in ptr *ptr = ‘a’; ‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’ ptr

12. int StringLength ( /* in */constcharstr[ ] ) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // Precondition: str is a null-terminated string // Postcondition: FCTVAL == length of str (not counting ‘\0’) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - { char* p ; intcount = 0; p = str; while ( *p != ‘\0’ ) { count++ ; p++ ; // increments the address p by sizeof char } return count; } 12

13. floating address float double long double pointer reference C++ Data Types simple structured integral enum array struct union class char short int long bool

14. Some C++ Pointer Operations Precedence Higher->Select member of class pointed to Unary: ++ -- ! * new delete Increment, Decrement, NOT, Dereference, Allocate, Deallocate + - Add Subtract < <= > >= Relational operators == != Tests for equality, inequality Lower = Assignment 14

15. Sintasix del Operador new new DataType new DataType [IntExpression] De haber memoria libre, new coloca el objeto o arreglo y devuelve un pointerde la dirección de memoria separada. De lo contrario, el programa termina con un mensaje de error. El objeto dinámicamente creado existe hasta que el operador de “delete” lo destruye. 15

16. El Pointer NULL Existe un pointer constante cero (0) llamado “null pointer” denotado como NULL en el “header file” cstddef. Pero NULL no es la dirección de memoria 0. NOTA: Es error hacer un “dereference” a un pointer cuyo valor sea NULL. Esto podría hacer que el programa aborte o actue de forma rara. Es responsabilidad del programador cotejar lo siguiente; while (ptr != NULL) { . . .// ok to use *ptr here }

17. 3 Tipos de Datos en Memoria • STATIC DATA: Su localización en memoria existe a lo largo de la ejecución de todo el programa static long currentSeed; • AUTOMATIC DATA: Crea los datos en una funcion cuando es invocada y los destruye cuando la función termina de ejecutarse • DYNAMIC DATA: Crea y destruye datos en memoria durante la ejecución de un programa. Utiliza los operadores new y delete

18. “Allocation” de la Memoria DYNAMIC ALLOCATION Dinámicamente separa espacio en memoria al ejecutarse el programa (“run time“ al utilizar el operador new. STATIC ALLOCATION Separa espacio en memoria en “ compile time”.

19. Asignar Datos a Memoria Dinámicamente 2000 ptr char* ptr; ptr = new char; *ptr = ‘B’; cout << *ptr;

20. Asignar Datos a Memoria Dinámicamente 2000 ptr char* ptr; ptr = new char; *ptr = ‘B’; cout << *ptr; NOTA: Data dinámica no tiene nombre de variable

21. Asignar Datos a Memoria Dinámicamente 2000 ptr ‘B’ char* ptr; ptr = new char; *ptr = ‘B’; cout << *ptr; NOTA: Data dinámica no tiene nombre de variable

22. Asignar Datos a Memoria Dinámicamente 2000 ptr NOTA: delete - Libera de memoria la localización apuntada por ptr char* ptr; ptr = new char; *ptr = ‘B’; cout << *ptr; delete ptr; ?

23. Utilizando el Operador delete El operador delete devuelve el área de memoria que se estaba utilizando y que fue asignada previamente por el operador new. El objeto o arreglo al que estaba apunto se desactiva, y el pointer se considera como que esta sin valor alguno asignado. 23

24. Asignar Dinámicamente a un Arreglo char *ptr;// ptr is a pointer variable that // can hold the address of a char ptr = new char[ 5 ]; // dynamically, during run time, allocates // memory for a 5 character array // and stores the base address into ptr 6000 6000 ptr

25. Asignar Dinámicamente a un Arreglo char *ptr ; ptr = new char[ 5 ]; strcpy( ptr, “Bye” ); ptr[ 1 ] = ‘u’; // a pointer can be subscripted cout << ptr[ 2] ; 6000 ‘u’ 6000 ‘B’ ‘y’ ‘e’ ‘\0’ ptr

26. Sintaxis del Operator delete delete Pointer delete [ ] Pointer Si el valor del pointer es 0 no hay efecto. De lo contrario, el objeto o arreglo apuntado por Pointer se elimina (“deallocated”), y el valor de Pointer es indefinido. Se devuelve el area eliminada a memoria libre (“free”). Los “brackets”se utilizan para eliminar un arreglo dinámicamente creado. 26

27. Desasignar Dinámicamente un Arreglo char *ptr ; ptr = new char[ 5 ]; strcpy( ptr, “Bye” ); ptr[ 1 ] = ‘u’; delete ptr;// deallocates array pointed to by ptr // ptr itself is not deallocated // the value of ptr is undefined. ? ptr

28. ¿Qué ocurre aquí? 3 ptr int* ptr = new int; *ptr = 3; ptr = new int; // changes value of ptr *ptr = 4; 3 ptr 4

29. Objeto Inacesible Es un Objecto creado por el operador new y el cual se dejo de apuntar por alguna razón. int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; 8 ptr -5 ptr2

30. Creando un Objeto Inacesible 8 ptr -5 ptr2 int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; ptr = ptr2;// here the 8 becomes inaccessible 8 ptr -5 ptr2

31. Memory Leak Un “memory leak” es la perdida de espacio de memoria disponible que ocurre cuando se definen (“allocate”) datos dinámicamente, pero nunca se destruyen (“deallocated”).

32. Un “Dangling Pointer” Es un pointer que apunta a un área de memoria dinámica que ha sido eliminada (“deallocated”) int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; ptr = ptr2; 8 ptr -5 ptr2 Por Ejemplo,

33. Creando un “Dangling Pointer” 8 ptr -5 ptr2 int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; ptr = ptr2; delete ptr2; // ptr is left dangling ptr2 = NULL; 8 ptr NULL ptr2