View
222
Download
0
Category
Preview:
Citation preview
1
Chapter 15
Pointers, 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
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
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
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
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
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
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
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
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
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
C++ Data TypesC++ Data Types
structured
array struct union class
address
pointer reference
simple
integral enum
char short int long bool
floating
float double long double
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 = Assignment14
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
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 programastatic 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
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
2000
ptr
Asignar Datos a Memoria Dinámicamente
char* ptr;
ptr = new char;
*ptr = ‘B’;
cout << *ptr;
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
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
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
?
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
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
6000
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
6000 ‘B’ ‘y’ ‘e’ ‘\0’ ‘u’
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
int* ptr = new int;
*ptr = 3;
ptr = new int; // changes value of ptr
*ptr = 4;
¿Qué ocurre aquí?
3
ptr
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
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
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
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
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
Recommended