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

Presentación del tema: "1 Chapter 15 Pointers, Dynamic Data, and Reference Types Dale/Weems/Headington."— Transcripción de la presentación:

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

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

3 3 Recordar que... char str [ 8 ]; str es 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. str [0] [1] [2] [3] [4] [5] [6] [7] ‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’ 6000

4 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 x number ch

5 5 Obteniendo Direcciones de Memoria l 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 6 ¿Qué es una variable tipo pointer? l Es una variable cuyo valor es la dirección (“address”) de una localización de memoria. l 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 7 Utilizando una Variable tipo Pointer 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 2000 12 x 3000 2000 ptr

8 8 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 El operator unario * es un operador indirecto (“deferencia”)

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

10 10 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 Otro Ejemplo 4000 A Z ch 5000 6000 4000 4000 q p

11 11 ptr Utilizando un Pointer para aceder los Elementos de un String ‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’ 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’;

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

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

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 pointer de 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 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 17 3 Tipos de Datos en Memoria l STATIC DATA: Su localización en memoria existe a lo largo de la ejecución de todo el programa static long currentSeed; l 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 18 “Allocation” de la Memoria STATIC ALLOCATION Separa espacio en memoria en “ compile time”. DYNAMIC ALLOCATION Dinámicamente separa espacio en memoria al ejecutarse el programa (“run time“ al utilizar el operador new.

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

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

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

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

23 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. Utilizando el Operador delete 23

24 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 ptr 6000

25 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] ; ptr 6000 ‘B’ ‘y’ ‘e’ ‘\0’ ‘u’

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 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 28 int* ptr = new int; *ptr = 3; ptr = new int; // changes value of ptr *ptr = 4; ¿Qué ocurre aquí? 3 ptr 3 ptr 4

29 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 30 Creando un Objeto Inacesible int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; ptr = ptr2; // here the 8 becomes inaccessible 8 ptr -5 ptr2 8 ptr -5 ptr2

31 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 32 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; Un “Dangling Pointer” 8 ptr -5 ptr2 Por Ejemplo,

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