Propedéutico de Programación Coordinación de Ciencias...

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


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


Memory Leak

A memory leak is the loss of available memory space that occurs when dynamic data is allocated but never deallocated


• A dangling pointer is a pointer that

points to dynamic memory that has been deallocated

A Dangling Pointer


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


Ejemplo

• corrida_dangling.pdf

• apuntadores2.cpp

corrida_dangling.pdf

apuntadores2.cpp

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

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

Message.cpp

Tipos de constructores/destructores

• Class constructor

• Class destructor

• Deep copy operation

• Class copy constructor

• Ver Message.h

• Ver MessageDemo.cpp

Message.h

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

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:

Message.cpp

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”

Message.cpp

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: : };

Propedéutico de Programación Coordinación de Ciencias...

Documents

Transcript of Propedéutico de Programación Coordinación de Ciencias...