Clases y manejo de memoria dinámica en C++ - Universidad de ...

Programación Orientada a Objetos 

3 – Clases manejo de memoria dinámica en C++ - 1 - 

Clases y manejo de memoria dinámica en C++ 

Repaso a las funciones de manejo de memoria dinámica en C ............................................................................1 

Función calloc()...................................................................................................................................................1 

Función malloc() .................................................................................................................................................2 

Función realloc() .................................................................................................................................................2 

Función free() ......................................................................................................................................................3 

El operador new frente a malloc ............................................................................................................................3 

El operador delete frente a free..............................................................................................................................8 

Sobrecarga de new y de delete................................................................................................................................9 

Sobrecarga de new y delete respecto a una clase específica.............................................................................11 

Clases con punteros miembros .............................................................................................................................14 

El Puntero this ......................................................................................................................................................22 

Funciones estáticas y el puntero this.................................................................................................................24 

Paso y retorno de objetos......................................................................................................................................24 

Paso y retorno de referencias a objetos................................................................................................................26 

Ejercicios propuestos ............................................................................................................................................27 

Repaso a las funciones de manejo de memoria dinámica en C 

Función calloc() 

Prototipo: void *calloc(int num, int tam); 

Archivo cabecera: stdlib.h 

Valor devuelto: Devuelve un puntero al primer byte del bloque de memoria reservada, o un 

puntero 

NULL en el caso de no haberse podido reservar el bloque de memoria solicitado 

Finalidad: Reserva un bloque de memoria para almacenar num elementos de tam bytes cada 

uno de ellos. Todo el bloque de memoria queda iniciado a 0. 

• num: indica el número de elementos con la misma estructura que ocuparán el bloque de memoria reservado. 

• tam: indica el tamaño en bytes de cada uno de los elementos que van a ocupar el bloque de memoria 

reservada. 

La cantidad de memoria reservada viene determinada por el resultado que se obtiene al multiplicar el número de 

elementos a almacenar en el bloque de memoria por el tamaño en bytes de cada uno de esos elementos, es decir, 

num * tam. 

El uso de esta función se puede ilustrar con el siguiente ejemplo: 

int n=100, *pt; 

... 

pt = ( int * ) calloc (n, sizeof(int)); 

En este ejemplo la función calloc reserva un bloque de memoria de n enteros, y retorna un puntero void a dicho 

bloque, o NULL si n fuera 0 o se produjera un error al no poder reservar suficiente espacio para reservar la 

Ingeniería Técnica en Informática de Sistemas (3er curso) 

Departamento de Informática y Automática – Universidad de Salamanca (versión Febrero 2003)



memoria solicitada. Sobre el puntero que se retorna se debe hacer una operación de cast apropiada, para 

asignarlo al puntero del tipo que se está tratando. 

Función malloc() 

Prototipo: void *malloc(int tam); 



puntero 


Finalidad: Reserva un bloque de memoria de tam bytes. 

• tam: indica el tamaño en bytes del bloque de memoria que se desea reservar. 

La cantidad de memoria reservada será de tam bytes. 

El uso de esta función se puede ilustrar con el siguiente ejemplo: 

struct Registro *ptr_reg; 

ptr_reg = ( struct Registro * ) malloc (sizeof (struct Registro)); 

La función malloc reserva un bloque de memoria lo suficientemente grande como para acoger por completo al 

tipo de dato, y retorna un puntero void a dicho bloque, o NULL si el tamaño del argumento es 0 o se ha 

producido un error al no poder reservar suficiente espacio para alojar al tipo de dato. Sobre el puntero que se 

retorna se debe hacer una operación de cast apropiada, para asignarlo al puntero del tipo que se está tratando. 

Función realloc() 

Prototipo: void *realloc(void *ptr, int nuevo_tamaño); 



puntero 


Finalidad: Cambia el tamaño del bloque de memoria apuntada por ptr al nuevo tamaño 

indicado por nuevo_tamaño 

• ptr: puntero que apunta al bloque de memoria reservado. 

• nuevo_tamaño: valor en bytes que indica el nuevo tamaño del bloque de memoria apuntado por ptr y que 

puede ser mayor o menor que el original. 

En estas tres funciones es importante comprobar que el puntero devuelto por ellas no es un puntero nulo 

(NULL) antes de hacer uso del bloque de memoria reservado. 





Función free() 

Prototipo: void free(void *ptr); 


Valor devuelto: Ninguno 

Finalidad: Libera el bloque de memoria apuntada por ptr y que previamente ha sido asignado 

mediante malloc() o calloc(). 

• ptr: variable puntero que debe contener la dirección de memoria del primer byte del bloque de memoria que 

deseamos liberar. En caso de que no sea un puntero previamente reservado por malloc() o calloc(), la 

llamada a la función free() puede ocasionar una parada o interrupción del sistema. 

El operador new frente a malloc 

En el lenguaje C, la región de memoria que está disponible a la hora de la ejecución recibe el nombre de heap. 

En C++ el espacio de memoria disponible se conoce como almacenamiento libre 1 . La diferencia entre los dos se 

encuentra en las funciones que se utilicen para el acceder a esta memoria. 

El método para solicitar memoria del heap en C se basa en el uso de la función malloc y sus derivadas (calloc, 

realloc, ...). En C++ no es correcto utilizar malloc para alojar de forma dinámica una nueva instancia de una 

clase. La razón es que si se usa malloc, se pierden las ventajas que nos ofrecen los constructores, ya que se llama 

al constructor de la clase cada vez que se crea un objeto. Si se usa malloc para crear un objeto, se tiene un 

puntero a un bloque de memoria sin iniciar. Entonces se pueden hacer llamadas a métodos con objetos que no 

están bien construidos, y que por lo tanto van a dar resultados erróneos. 

La técnica más adecuada es utilizar la alternativa que ofrece C++ mediante el operador new. 

El operador new conoce la clase del objeto, o el tipo de la variable, que se quiere alojar en el almacenamiento 

libre. De esta forma este operador llama automáticamente al constructor que corresponda, dependiendo de los 

argumentos que se especifiquen, para iniciar la memoria que ha reservado. 

La forma de utilizar este operador es la siguiente: 

= new []; 

De la sintaxis de new se puede deducir que no es una función, y que por lo tanto no tiene una lista de 

argumentos entre paréntesis. Es un operador que se aplica al nombre del tipo, pero no se tiene que realizar un 

cast 2 ni utilizar el operador sizeof para determinar su tamaño, porque new conoce el tipo de dato y su tamaño. 

Si new no encuentra espacio para alojar lo que se le pide, devuelve 0 3 . 

El operador new reemplaza a las funciones malloc y calloc de la biblioteca estándar de C, pero no sustituye a 

realloc. La función realloc puede ser simulada, pero la aproximación que se haga supondrá siempre un aumento 

1 

Free store. 

2 

El compilador comprueba que el tipo del puntero que devuelve new y el tipo del puntero al que se asigna son 

del mismo tipo. En caso contrario genera un error. 

3 

En C++ un puntero nulo vale 0 en lugar de NULL. 





de las líneas del código fuente, así como conocer el tamaño original del espacio reservado mediante el puntero 

que se va cambiar. Pero afortunadamente se puede utilizar generalmente realloc para cambiar el tamaño del 

espacio reservado con new. 

Como se ha dicho, con new se puede reservar espacio para cualquier tipo de dato, siendo muy utilizado para 

reservar espacio para matrices 4 . Un ejemplo: 

float *centros; 

centros = new float[numero]; 

Para ilustrar todo lo visto hasta el momento del operador new se ha realizado este sencillo programa de ejemplo: 

// Programa: malloc versus new 

// Fichero: MALVNEW.CPP 

#include 



class Prueba { 

int i, j; 

char *s; 

public: 

Prueba() { // Constructor por defecto 

i=j=5; 

s=new char[5]; 

strncpy(s, "Hola", 5); 

} 

Prueba(char *cad, int a, int b) { // Constructor con parámetros 

i=a; j=b; 

s=new char[strlen(cad)+1]; 

strcpy(s, cad); 

} 

~Prueba () {delete [] s;} // Destructor 

int miembro(void) { // Función para mostrar los datos de la clase 

cout



void main (void) 

{ 

// Creamos un objeto dinámico con malloc 

Prueba *P1; 

P1=(Prueba *) malloc (sizeof (Prueba)); 

// Y nos vamos a estrellar: Salen caracteres raros por pantalla e 

// incluso se puede colgar el programa 

cout



C++ define un puntero a función, de forma que cuando ocurre un error, la función a la que apunta el puntero es 

llamada. La definición de dicho puntero es: 

void (* _new_handler)(); 

El uso de este puntero tiene el inconveniente de no ser estándar. Por ello se recomienda el uso de una función de 

biblioteca definida en new.h, y que se llama set_new_handler, que toma como argumento un puntero a función, 

y asigna la función al puntero _new_handler. Aunque este segundo método es más común, y por lo tanto más 

conveniente, tampoco es estándar 7 . 

// Programa: Manejo de errores en la reserva de espacio con new 

// Versión Borland C++ 

// Fichero: NEW_ERR.CPP 




#define PASO 20000 

void MemoriaInsuficiente(void) 

{ 

cerr



// Programa: Manejo de errores en la reserva de espacio con new 

// Versión Microsoft C++ 

// Fichero: NEW_ERR.CPP 




int MemoriaInsuficiente(size_t size) 

{ 

cerr



El operador delete frente a free 

El operador delete se puede decir que es para new, lo que free para malloc. Esto es, libera los bloques de 

memoria, dejándolos listos para futuras reservas. 

La sintaxis de delete es muy sencilla: 

delete ; 

Cuando se trata de liberar el espacio asociado un puntero a un objeto, delete de forma automática llama al 

destructor. 

El operador delete se debe utilizar sólo con punteros que retorne new. Mientras que la función free se debe usar 

con punteros que apunten a zonas de memoria reservadas mediante funciones derivadas de malloc. De no 

hacerse así, y dependiendo de los compiladores, puede causar graves problemas 9 . Si se intenta liberar dos veces 

un mismo puntero, los resultados pueden ser catastróficos. Estas dos circunstancias deben ser controladas por el 

programador, ya que el compilador no las detecta. 

Se puede liberar un puntero nulo sin consecuencias adversas. 

El uso de delete con los tipos preestablecidos no tiene misterios, salvo en el caso de las matrices, que se debe 

usar la siguiente sintaxis: 

delete [tamaño] ; 

En la mayoría de los compiladores basta con poner los corchetes vacíos, ya que ignoran el número que se ponga 

entre ellos. 

Un sencillo ejemplo del uso del operador unario delete puede ser el siguiente: 

// Programa: Uso de delete 

// Fichero: DELETE1.CPP 




{ 

int *i, *vi; 

} 

i=new int; 

*i=6; 

vi= new int[2]; 

vi[0]=0; vi[1]=1; 

cout



Sobrecarga de new y de delete 

En C++ es posible redefinir los operadores new y delete sobrecargándolos, si se quiere construir un 

procedimiento de manejo de memoria personalizado. 

Los esqueletos de las funciones que sobrecargan estos operadores son: 

void *operator new (size_t tamaño) 

{ 

// Reserva dinámica 

return puntero_void; 

} 

void operator delete (void puntero) 

{ 

// Liberar memoria a la que apunta el puntero 

} 

El operador new toma como argumento un tipo size_t que es un tipo entero que puede contener el mayor bloque 

individual de memoria que se pueda reservar. El número de bytes a reservar se indican mediante el parámetro 

tamaño. Además cualquier operador new que se cree debe devolver un puntero void. 

En cuanto al operador delete toma como argumento un puntero de tipo void, el cual apunta a la zona de 

memoria que debe liberar. Además cualquier operador delete que sea creado por el programador no debe 

retornar nada. 

Si se redefine el operador new de esta forma se sigue llamando al constructor de la clase cuando se tiene una 

instancia dinámica de una clase. 

Sin embargo, puede surgir algún tipo de problemas, cuando se sobrecargan estos operadores, con el uso de 

realloc debido a que el nuevo sistema de manejo de memoria dinámica utilice las mismas técnicas de manejo de 

memoria que las funciones de biblioteca del C. 

Para ilustrar la sobrecarga de los operadores new y delete se va ha realizar un sencillo programa que inicie el 

contenido del bloque de memoria que se quiere reservar a 0 antes de utilizarlo 10 . 

// Programa: Sobrecarga de los operadores new y delete 

// Fichero: N&DOVER1.CPP 




void *operator new ( size_t s ) { 

void *ptr=calloc(1, s); 

return ptr; 

} 

void operator delete ( void * ptr ) { 

free ( ptr ); 

} 

10 Se utilizará la función calloc porque ésta inicia a 0 todo el bloque de memoria que reserva. 









void main(void) { 

float *p=new float[5]; 

for (register int i=0; i



Cuando se va a procesar el operador new para una instancia de una clase, el compilador primero comprueba si 

están definidos para dicha clase, y en caso afirmativo utiliza las versiones específicas de la clase. En caso 

contrario, si han sido sobrecargados globalmente, emplea estas nuevas versiones globales, y en último caso 

utilizaría los operadores estándar new y delete. 

Para ilustrar la sobrecarga de estos operadores respecto de una clase, se presenta el siguiente ejemplo: 

// Programa: Sobrecarga de los operadores new y delete respecto de una 

// clase 

// Fichero: N&DOVER3.CPP 




#define NOMBRES 10 

class Nombre { 

char nombre[25]; 

public: 

Nombre ( const char * ); 

void Presenta ( void ) const; 

void *operator new (size_t s); 

void operator delete (void *ptr); 

~Nombre() {}; // Destructor que no hace nada 

}; 

// Memoria para manejar un número fijo de instancias de la clase Nombre 

char memo[NOMBRES] [sizeof (Nombre)]; 

int en_uso[NOMBRES]; 

// Funciones miembro de la clase Nombre 

Nombre::Nombre ( const char *cad ) 

{ 

strncpy (nombre, cad, 25 ); 

} 

void Nombre::Presenta ( void ) const 

{ 

cout



void Nombre::operator delete ( void * ptr ) 

{ 

en_uso[ ( (char *)ptr - memo[0] ) / sizeof ( Nombre ) ] = 0; 

} 

void main ( void ) 

{ 

Nombre * directorio [NOMBRES]; 

char nombre[25]; 

} 

for (register int i=0; i



Clases con punteros miembros 

Una práctica habitual es utilizar los operadores new y delete en las funciones miembros de una clase, como ya 

se ha visto en varios de los ejemplos que hasta ahora se han presentado. 

Pero en este apartado se va a estudiar con más profundidad esta posibilidad, comentando ciertos problemas que 

pueden surgir, y la forma de solventarlos. 

Para ello se va a crear una clase Cadena para el manejo de cadenas de caracteres, que el lector puede 

personalizar y ampliar como ejercicio práctico de programación. 

CADENA.H 

#ifndef __CADENA_H__ 

#define __CADENA_H__ 



class Cadena { 

char *cadena; 

unsigned longitud; 

public: 

Cadena(void); 

Cadena(const char *); 

Cadena(char, unsigned); 

void CambiaCaracter(int, char); 

char MuestraCaracter(int) const; 

int Longitud(void) const {return longitud;} 

void Muestra(void) const {cout



Cadena::Cadena(const char *cad) 

{ 

longitud=strlen(cad); 

cadena=new char[longitud+1]; 

strcpy(cadena, cad); 

} 

Cadena::Cadena(char c, unsigned n) 

{ 

longitud=n; 

cadena=new char[n+1]; 

memset(cadena, c, n); 

cadena[n]='\0'; 

} 

// Funciones miembro de la clase Cadena 

void Cadena::CambiaCaracter(int indice, char c) 

{ 

if ( (indice >= 0) && (indice= 0) && (indice



CADDEMO1.CPP 

// Programa: Clases con punteros miembros. Clase Cadena 

// Fichero Principal. 

// Fichero: CADDEMO1.CPP 

#include "cadena.h" 

void main(void) 

{ 

Cadena Micadena ("esta es mi cadena."); 

} 

Micadena.Muestra(); 

cout



#include "cadena.h" 


void main(void) 

{ 

Cadena c1("Esta es la primera cadena"), 

c2("Esta es otra cadena"); 

clrscr(); 

cout







En el ejemplo se han creado dos objetos c1 y c2 de la clase Cadena. Para después hacer una asignación de c1 en 

c2. Cuando se realiza una asignación de un objeto a otro, el compilador realizaría lo siguiente: 

c2.longitud = c1.longitud; 

c2.cadena = c1.cadena; 

En la asignación del miembro longitud no hay ningún problema. sin embargo, como el miembro cadena es un 

puntero, el resultado de la asignación es que c1.cadena y c2.cadena apuntan a la misma zona de memoria. Es 

decir, ambos objetos comparten la cadena de caracteres. 

De forma gráfica: 

Aquí esta la explicación de los efectos no deseados que encontrábamos en el programa CADDEMO2.CPP. 





Otros problemas más graves se pueden llegar a dar cuando el objeto sale del alcance donde fue definido. Cuando 

el destructor de la clase se llama para el objeto c1, se elimina dicho objeto liberándose también la memoria 

donde apuntaba el puntero cadena. Cuando el destructor se llama de nuevo para el objeto c2, se eliminará el 

puntero miembro cadena. Pero como los dos miembros cadena de ambos objetos tienen el mismo valor, 

significa que un puntero ha sido eliminado dos veces, esto puede tener consecuencias imprevistas. 

Además, el contenido original del miembro cadena del objeto c2 se ha perdido, y ese bloque de memoria no será 

liberado. 

Este problema ocurre con cualquier clase que contiene punteros miembro y reserva memoria del 

almacenamiento libre. 

En conclusión el operador de asignación que nos ofrece por defecto el compilador, no es adecuado para usarlo 

entre clases. La solución será reemplazar el que se nos ofrece por defecto por uno escrito por nosotros mismos, y 

que realmente realice la asignación de forma adecuada. 

Como ya es sabido, una de las características del C++ es que se permite la sobrecarga de operadores 12 . Lo que se 

va a hacer es dotar al operador de asignación de un significado especial cuando se refiera a la clase Cadena. 

Para redefinir el operador de asignación se debe crear una función miembro que se llame operator=. De esta 

forma cuando se vaya a realizar una asignación entre objetos de la clase Cadena, el compilador utilizará el 

operador de asignación escrito para dicha clase. 

El nuevo operador de asignación puede ser algo como: 

// Operador de asignación 

void Cadena::operator= (const Cadena &fuente) 

{ 

longitud = fuente.longitud; 

delete [ ] cadena; 

cadena = new char[longitud + 1]; 

strcpy ( cadena, fuente.cadena); 

} 

12 Que se estudiará con detalle más adelante 





El operador recibe como parámetro una referencia como constante 13 a un objeto Cadena. El resultado ahora es 

correcto, y se ilustra en la siguiente figura: 

Una vez modificado el fichero cabecera, y el fichero cuerpo de la clase, compilar y ejecutar el programa 

CADDEMO2.CPP. 

Pero que ocurriría si se realiza una auto asignación c1 = c1; Esto que parece absurdo, y que casi nadie va a 

utilizar tiene otras formas más comunes: 

Cadena *Ptr_cad = &c1; 

// Más adelante ... 

c1 = *Ptr_cad; 

Lo que ocurrirá es que en la definición del nuevo operador de asignación, primero borra la cadena de caracteres, 

y después reserva un nuevo espacio, donde copia el contenido del espacio recién reservado en él mismo. Esto 

tiene como resultado que se introduce basura, y la pérdida de la cadena de caracteres del objeto. Para que el 

operador trabaje bien en todos los casos, se debe utilizar el puntero this 14 para prever el caso de la auto 

asignación. 

Cuando una clase tiene punteros miembro, se debe tener en cuenta a la hora de trabajar con constructores copia. 

Como se vio cuando se trató el tema de los constructores copia, estos iniciaban un objeto con los valores de otro 

objeto. Aquí se tiene involucrado el uso del operador asignación. Pero como se ha visto en este mismo apartado, 

el operador de asignación por defecto nos va a dar resultados erróneos si la clase tiene punteros miembro. Así si 

se hiciera lo siguiente: 

Cadena c2(c1); 

Se estaría iniciando el objeto c2 con los valores del objeto c1, pero al utilizar el operador de asignación por 

defecto, lo que se estaría haciendo es que tanto c1 como c2 apuntarán a la misma cadena de caracteres. 

13 Indicando que dicho operador no puede modificar el objeto que recibe 

14 El puntero this se estudia en el siguiente apartado. Por lo que respecta a la correcta manera de crear el 

operador de asignación para la clase Cadena, realizar el ejercicio 3 de este mismo capítulo. 





La solución pasa por construir un constructor copia propio. Como ejemplo se va a escribir el constructor copia 

para la clase Cadena. 

// Constructor Copia 

Cadena::Cadena ( const Cadena &fuente) 

{ 

longitud = fuente.longitud; 

cadena = new char [longitud +1]; 

strcpy (cadena, fuente.cadena); 

} 

La realización del constructor copia es muy similar a la realización del operador asignación. Pero hay algunas 

diferencias entre ellos: 

Un operador de asignación actúa sobre un objeto que existe, mientras que un constructor copia crea uno 

nuevo. Como resultado, un operador de asignación puede tener que borrar la memoria que se reservó 

originalmente para el objeto que recibe los datos. 

Un operador de asignación tiene que comprobar las auto asignaciones. El constructor copia no tiene que 

hacerlo, porque en su caso no existen auto asignaciones. 

Para permitir asignaciones encadenadas, un operador de asignación debe retornar *this. Por ser un 

constructor, el constructor copia no puede devolver valores. 

El Puntero this 

Cada vez que se invoca a una función miembro, se le pasa automáticamente un puntero al objeto que la ha 

invocado 

Se puede acceder a ese puntero utilizando la palabra reservada this 

El puntero this es un parámetro implícito a toda función miembro 15 

Para acceder a un elemento concreto de un objeto cuando se utiliza el objeto en sí, se emplea el operador 

punto (.) 

Para acceder a un elemento concreto de un objeto cuando se utiliza un puntero al objeto, se emplea el 

operador flecha (->) 

Cuando se llama a una función miembro, el compilador asigna la dirección del objeto al puntero this, y después 

se llama a la función. Cada vez que una función miembro accede a un dato miembro, se está utilizando de forma 

implícita el puntero this. 

Por ejemplo considérese el siguiente programa en C++: 


class D { 

int i,j,k; 

public: 

D() {i=j=k=0;} 

15 Excepto para las funciones miembro static 





void Mostrar(void) 

{ 

cout



El puntero this es un puntero constante, por lo tanto una función miembro no puede cambiar el valor del 

puntero, y hacer que apunte a otro sitio. Sin embargo, en las primeras versiones de C++, el puntero this no era 

constante, y esto permitía al programador hacer asignaciones al puntero this para personalizar el manejo de la 

memoria dinámica. Esto ya no está permitido en las últimas versiones de C++. 

Funciones estáticas y el puntero this 

Cuando en el capítulo anterior se abordó el tema de las funciones miembro static, se definieron como aquellas 

que sólo podían trabajar con miembros dato estáticos. Esto es debido a que este tipo de funciones carecen de 

puntero this. 

Pero el problema surge si una función necesita de forma imperiosa acceder a un miembro dato de una clase. Para 

solucionarlo se le ha de pasar de forma explícita un puntero this. Véase el siguiente ejemplo: 

// Programa: Funciones miembro estáticas y el puntero this 

// Fichero: STTHIS.CPP 


class Prueba { 

int a, b; 

static int decre; 

public: 

Prueba () {a=b=0;} 

Prueba (int a1, int b1=0) {a=a1; b=b1;} 

static int Ejemplo(Prueba *E) {return E->a+E->b-decre;} 

}; 

int Prueba::decre=1; 


{ 

Prueba P1(1,2); 

cout



void main () 

{ 

Cadena c1("Cadena de ejemplo"); 

ProcesaCadena ( c1); 

} 

La función ProcesaCadena recibe un objeto que se pasa por valor. Esto significa que la función tiene su propia 

copia privada del objeto. 

El parámetro de la función se inicia con el objeto que se pasa como argumento. El compilador de forma implícita 

llama al constructor copia para realizar esta iniciación. 

Si no se define un constructor copia para realizar la iniciación, el compilador realiza su constructor copia por 

defecto, y el objeto cad y el objeto c1 tendrían la misma cadena de caracteres, y por lo tanto cualquier 

modificación en la cadena de caracteres de cad modificaría la cadena de caracteres del objeto c1. 

También habría problemas en cuanto que el objeto cad tiene un alcance local, y por lo tanto al salir de la función 

se llamaría al destructor. Esto significa que el objeto c1 tendría un puntero que apuntaría a una zona de memoria 

que ya ha sido liberada, lo cual iba a ser poco recomendable. 

Ahora supongamos un extracto de fuente en C++ donde se incluye una función que retorna un objeto Cadena. 

// Función que retorna un objeto Cadena 

Cadena RetCadena ( void ) 

{ 

Cadena valor ( "Esto es una prueba."); 

return valor; 

} 

void main () 

{ 

Cadena c1; 

c1 = RetCadena(); 

} 

La función RetCadena retorna un objeto Cadena. El compilador llama al constructor copia para iniciar un 

objeto temporal y oculto en el alcance de la llamada, usando el objeto que se especifica en la sentencia return. 

Este objeto temporal es usado como parte derecha de la asignación que hay en el programa principal. 

De nuevo, se necesita un constructor copia. En otro caso el objeto temporal compartiría la misma cadena de 

caracteres que el objeto valor, el cual será eliminado cuando la función RetCadena finalice su ejecución, y en 

consecuencia la asignación que se hace a c1 no está garantizada. 

Como regla a seguir, se debe definir siempre un constructor copia y un operador de asignación cuando se 

tenga una clase que contenga punteros miembro y reserve espacio del almacenamiento libre. 





Paso y retorno de referencias a objetos 

En el apartado anterior se ha visto como cada vez que se pasaba un objeto a una función por valor, se llamaba al 

constructor copia. 

Una forma de simular el paso por valor de un objeto, pero sin tener que llamar al constructor copia sería utilizar 

referencias a objetos constantes. 

Estudiemos el mismo ejemplo que se vio en el apartado anterior, pero ahora la función recibe una referencia al 

objeto constante. 

// Función que recibe un objeto Cadena como argumento 

void ProcesaCadena ( const Cadena &cad ) 

{ 

// Usa el objeto cad 

} 

void main () 

{ 

Cadena c1("Cadena de ejemplo"); 

ProcesaCadena ( c1); 

} 

Ahora el constructor copia no es llamado porque no se ha construido un nuevo objeto. En su lugar se inicia una 

referencia con el objeto que se le pasa. Como resultado se usa el mismo objeto que en la llamada a la función. 

El uso de la palabra reservada const es debido a que se quiere asegurar la integridad del objeto, esto es, que no 

se pueda modificar el objeto en la función. 

Igualmente que una función retorne una referencia en lugar de un objeto es mucho más eficiente. El constructor 

copia no se llama cuando se produce el valor de retorno, porque no se crea un objeto temporal, sólo se crea una 

referencia temporal. 





Ejercicios propuestos 

1. Indicar cuál de las siguientes frases es incorrecta y explicar los motivos 

a) La función delete sirve para liberar zonas de memoria que han sido reservadas mediante new. 

b) El uso de malloc está prohibido en C++ 

c) La función set_new_handler sirve para que una función determinada se encargue del manejo de los 

errores por falta de espacio en el manejo de memoria dinámica mediante el operador new. 

d) Cuando se crea un objeto con el operador new no se llama al constructor de la clase a menos que se 

indique de forma explícita mediante argumentos. 

e) Aunque no se debe, si se usa free para liberar un puntero a una instancia devuelto por new, se llama al 

destructor si existe. 

2. Reescribir la función cambia() del programa MALVNEW.CPP, reemplazando la función realloc por una 

simulación de ésta mediante el operador new. 

3. Tenemos la clase Cadena. 

class Cadena { 

char *cadena; 

unsigned longitud; 

public: 

Cadena(void); 

Cadena(const char *); 

Cadena(char, unsigned); 

void CambiaCaracter(int, char); 

char MuestraCaracter(int) const; 

int Longitud(void) const {return longitud;} 

void Muestra(void) const {cout



4. Modificar de nuevo el operador de asignación para que ahora también permita: c1=c2=c3; 

5. Un constructor copia tiene como argumento una referencia a un objeto en lugar de un objeto. ¿Por qué? 

6. Crear una clase apropiada para representar el tipo de dato número complejo. Un número complejo se 

representará como (a, b), donde a representa la parte real y b la imaginaria. 

Construir además las funciones apropiadas para: 

Asignar valor a un número complejo 

Imprimir un número complejo con el formato (a, b) 

Sumar dos números complejos 

Restar dos números complejos 

Multiplicar dos números complejos 

Construir, además, un pequeño programa principal que compruebe el comportamiento de esta clase. 

7. Crear una clase apropiada para representar el tipo de dato rectángulo. 

Construir además las funciones apropiadas para: 

Calcular el área de un rectángulo 

Calcular el perímetro de un rectángulo 

Dados dos rectángulos, determinar cual es el mayor, teniendo en cuenta que el mayor es aquel que tiene 

mayor área. 

Dados dos rectángulos, determinar si sin idénticos. Ser idénticos implica que tiene el mismo área y el 

mismo perímetro. 

Intercambiar los valores entre dos rectángulos 

Ordenar un vector de rectángulos, de mayor a menor 

8. Incluir a la clase Cadena definida en este documento los siguientes métodos: 

Invertir una cadena 

Pasar a mayúsculas 

Determinar si es un palíndromo 

Construir además una función que permita ordenar de mayor a menor un vector de Cadenas.

Clases y manejo de memoria dinámica en C++ - Universidad de ...

Create successful ePaper yourself

Delete template?

Save as template?