Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
Propedéutico de Programación
Coordinación de Ciencias
Computacionales
Semana 3,
Segunda Parte
Dra. Pilar Gómez Gil
http://ccc.inaoep.mx/~pgomez/cursos/programacion/
Versión 1.3 12.06.08
Chapter 15
Pointers, Dynamic Data, and
Reference Types (continuación)
Dale/Weems
int* ptr = new int;
*ptr = 3;
ptr = new int; // Changes value of ptr *ptr = 4;
What happens here?
3
ptr
3
ptr
4
Tomado de: Dale, N. Weems, C. Programming and problem solving With C++. 4th. Ed. Instructor material, 2005
Inaccessible Object
An inaccessible object is an unnamed object created by operator new that a programmer has left without a pointer to it.
int* ptr = new int;
*ptr = 8;
int* ptr2 = new int; *ptr2 = -5;
How else can an object become inaccessible?
8
ptr
-5
ptr2
Tomado de: Dale, N. Weems, C. Programming and problem solving With C++. 4th. Ed. Instructor material, 2005
Making an Object Inaccessible
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
Tomado de: Dale, N. Weems, C. Programming and problem solving With C++. 4th. Ed. Instructor material, 2005
Memory Leak
A memory leak is the loss of available memory space that occurs when dynamic data is allocated but never deallocated
Tomado de: Dale, N. Weems, C. Programming and problem solving With C++. 4th. Ed. Instructor material, 2005
• A dangling pointer is a pointer that
points to dynamic memory that has been deallocated
A Dangling Pointer
Tomado de: Dale, N. Weems, C. Programming and problem solving With C++. 4th. Ed. Instructor material, 2005
Significa “colgando”..
int* ptr = new int;
*ptr = 8;
int* ptr2 = new int;
*ptr2 = -5;
ptr = ptr2;
delete ptr2; // ptr is left dangling
ptr2 = NULL;
Leaving a Dangling Pointer
8
ptr
-5
ptr2
8
ptr
NULL
ptr2
Tomado de: Dale, N. Weems, C. Programming and problem solving With C++. 4th. Ed. Instructor material, 2005
Tipo de Dato “Reference”
ReferenceVariableDeclaration
DataType& Variable; DataType &Variable , &Variable; {
•Este tipo de variables también contienen direcciones de memoria •El único operador que manejan es inicialización, después de esto cada aparición de la variable es implícitamente “des-referenciado” •Normalmente las usamos para pasar argumentos tipo “by reference”
Tomado de: Dale, N. Weems, C. Programming and problem solving With C++. 4th. Ed.
Ejemplo Void Swap( float& x, float& y)
/* esta función intercambia el
contenido de 2 variables */
{
float temp = x ;
x = y ;
y = temp;
}
Llamado de la función:
Swap(alpha,beta);
Tomado de: Dale, N. Weems, C. Programming and problem solving With C++. 4th. Ed.
Clases y Datos Dinámicos
• Que pasa cuando una clase tiene un componente que es un dato dinámico?
• Ejemplo: Message.h
Clase Message
Message
Time time; Char* msg
void Print() Void CopyFrom(Message otherMsg); Message(Time time,const char* msgStr); Message( const Message& otherMsg ); ~Message();
Suponiendo que se generaran 2 mensajes..
int main() { Time time; // Time object string msg; // Input message time.Set(10, 30, 0); Message msg1(time, “Call Boby"); time.Set(10, 35, 30); Message msg2(time, “Call Sue");
Se tendría …
Consideraciones:
• Como se “libera el espacio dinámico cuando ya no se desea usar el objeto?
• Como se “copia” el contenido de todo el objeto, incluyendo a la parte generada dinámicamente
• Como se pasa este objeto como parámetro “by value”
Constructores
• El constructor tiene que apartar memoria para un arreglo dinámico de caracteres, con el tamaño requerido por el argumento (string) que se pase al constructor
• Ver Message.cpp
Tipos de constructores/destructores
• Class constructor
• Class destructor
• Deep copy operation
• Class copy constructor
• Ver Message.h
• Ver MessageDemo.cpp
Destructores
• Van precedidos por ~
• Son implícitamente invocados cuando se destruye el objeto, esto es, cuando “sale de zona de alcance” (termina el bloque en que está declarado, si es de tipo “automático” o termina el programa si es de tipo “estático”)
• No tiene argumentos ni “tipo”
• Ver ejemplo de destructor en Message.cpp
Copias superficiales vs. Copias profundas
• El estatuto de asignación en estos casos genera una copia superficial, es decir solo se copia el valor del apuntador del dato dinámico, pero no la información del dato.
• msg1 = msg2
genera:
Copias profundas
• Debe construirse un método que permita copiar no solo el objeto, sino también copiar datos que están apuntados
• Ver código del método CopyFrom() en Message.cpp
• El estatuto: msg1.CopyFrom(msg2);
dará como resultado:
35
30
Debe ser
Constructores tipo “copy class” • Cuando se pasan objetos by-value, o en un estatuto “return” por
default se pasan los valores a través de hacer una copia superficial, pero puede incluirse un “copy-class constructor” para hacer una copia de la parte dinámica.
• Este tipo de constructores tienen la forma:
class SomeClass { public: : SomeClass( const SomeClass& someObject); // Copy Constructor : } • No hay nada especial que diga que esto es un “copy class
constructor, excepto que hay como parámetro el mismo tipo del objeto
Ejemplo
• Ver código en Message.cpp
• Note que el código tiene la palabra “const” en la definición del parámetro; esto para evitar que se modifique otherMsg, aún y cuando pasa “by reference”
Ejemplo • Si no existiera un “copy constructor” y se
ejecutara el siguiente código:
int main() { Time time; time.Set(10,30,0); Message quizMsg(time, “Geography quiz”); : DoSomething(quizMsg); : Se mandaría una copia superficial como parámetro
(ver figura…)
Plantilla general para objetos con datos dinámicos Class SomeClass { public: : void CopyFrom( SomeClass anotherObject ); // A deep copy operation SomeClass( ...); //Constructor, to create data on the free store SomeClass( const SomeClass& anotherObject ); //Copy constructor, for deep copying in initializations ~SomeClass(); //Destructor, to cleanup the free store private: : };