FACULTAD NACIONAL DE INGENIERIA

INGENIERIA DE SISTEMAS E INGENIERIA INFORMATICA

METODOLOGIA DE LA PROGRAMACION II
LABORATORIO DE PROGRAMACION – SIS 2210
LABORATORIO NRO 10

Tema: Arreglos Dinámicos de Objetos

Logros a alcanzar:
 Comprende el uso de arreglos de objetos
 Implementa arreglos dinámicos de Objetos.

Fundamento Teórico:
Creación de objetos en forma dinámica.

Operadores New y Delete.

En C++ se puede asignar memoria utilizando el operador new y liberarse mediante el
operador delete. Estos operadores no se pueden combinar unos con otros, es decir debe
llamarse a delete solo con un puntero obtenido mediante new.

Los objetos también se les puede pasar un valor inicial con la sentencia new.

SINTAXIS:
<nombre del puntero >= new <tipo de dato>;
delete <nombre del puntero>;
<nombre del puntero> = new <tipo de dato> (valor inicial);

De la misma forma se pueden crear arreglos de objetos asignados dinámicamente, estos

arrays pueden utilizar la sentencia new.

DECLARACIÓN DEL ARRAY:

<nombre del puntero >= new <tipo de dato> [<numero de elementos>];
puntero = new tipo[tamaño];

PUNTEROS C++

Un puntero es una variable que almacena la dirección de memoria de un objeto. Los

punteros se utilizan para tres propósitos principales:

 para asignar nuevos objetos en el montón (heap),

  para pasar funciones a otras funciones
 para iterar elementos en matrices u otras estructuras de datos.

C++ proporciona punteros inteligentes para asignar objetos,

También se puede desreferenciar un puntero para recuperar el valor del objeto al que
apunta. El operador de acceso a miembros proporciona acceso a los miembros de un
objeto.

Un puntero se puede aumentar o disminuir para apuntar a otra ubicación en la memoria.

Esta operación se denomina aritmética de punteros.

NOTACION FLECHA.
Para acceder a cada una de las variables miembro de la clase se utiliza el operador dot o
punto (.), o bien el operador arrow o flecha (->).el operador flecha (->) se utiliza cuando se
dispone de la dirección de un objeto (en el puntero correspondiente), en lugar del nombre
del objeto.

Ejemplo de un arreglo creado en forma dinámica:

#include<iostream>
using namespace std;
int main( )
{
int *p; // Se declara el puntero
int i;
p = new int[5]; /* al puntero se le asigna la memoria en forma dinámica y se crea el
arreglo */
system(“cls”);
if (!p) // Se verifica que exista el puntero
{ cout<<”Error de asignacion\n”;
exit(1);
}
for (i = 0; i < 5; i++) // Para introducir datos al arreglo
p[i] = i+1;
for (i = 0; i < 5; i++) // Para mostrar los datos del arreglo
{
cout<<”Este es el entero en p[“<<i<<”]:”;
cout<<p[i]<<”\n”;
}
delete[ ] p; // Se libera la memoria reservada
}

Ejercicio en clase

En el siguiente programa se muestra el uso de arreglos dinámicos de objetos usando NEW

y DELETE
El programa crea una clase denominada alumno, la cual contiene un arreglo para el nombre
del alumno y un arreglo para sus notas. A partir de esta clase se crea un puntero al objeto
alumno y a partir de este puntero se libera memoria para un arreglo de objetos
alumno por medio de NEW y el puntero a objeto para incluir todos los alumnos de una
clase en tiempo de ejecución.

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
using namespace std;

#define CAL 5 // Define constante para el numero de calificaciones a manejar

class Alumno
{
private:
char nombre[50];
float calificaciones[CAL];
public:
Alumno( ){ };
~Alumno( ){ };
void ingresar( ); // Función set
void mostrar_nombre( ); // Muestra el nombre del alumno
void reporte( ); // Muestra las notas del alumno
};

void Alumno::ingresar( ) //Ingresa los datos de un alumno

{
fflush(stdin);
cout <<"Ingrese el Nombre del estudiante : ";
gets(nombre);
int i;
for (i = 0; i < CAL; i++)
{
cout << "Por favor ingrese la calificacion No. " << i+1; cout <<" : ";
cin >> calificaciones[i+1];
}
}

void Alumno::mostrar_nombre()
{
cout << nombre;
}
void Alumno::reporte()
{
int i;
cout<<"------------------------------------------------------"<<endl;
// Se le da formato a la tabla.
for (i = 0; i < CAL; i++)
{
cout<<setw(15)<<"Nota "<<i+1<<" : "<<calificaciones[i+1]<<setw(5)<<endl;
}
}

int main( )
{
int num_est = 0; // Número del objeto en el vector
int numero_objeto = 0; // Apuntador del número del objeto
int opcion; // Opción del menú
char nom[50]; // Arreglo de 50 caracteres para el nombre
int i=0; // Auxiliar
int n=0; // Opción en el menú
int dim; // Dimensión del arreglo de objetos
Alumno *p; // Crea un puntero a objeto alumno
cout << "Cuantos alumnos tiene la clase? ";
cin >> dim; //Para cuantos objetos hay que reservar memoria?
cout << "\n";
p = new Alumno[dim]; /* Asigna memoria dinámicamente y se crea el arreglo de tipo Alumno */
if (p == 0) //Si p = 0 no hay memoria suficiente
{
cout << "Error no hay suficiente memoria";
return 0; //Sale del programa
};

do
{
cout<<" Menu"<<endl;
cout<<" 1. Ingresar datos de un nuevo estudiante. (Nombre y notas)"<<endl;
cout<<" 2. Ver lista de estudiantes inscritos."<<endl;
cout<<" 3. Reporte de un estudiante."<<endl;
cout<<" 4. Salir."<<endl;
cout<<"------------------------------------------------"<<endl;
fflush(stdin);
cout<<"\n Elija una opcion del menu (1-4): ";
cin>>opcion;
switch (opcion)
{
case 1:
(p+numero_objeto) -> ingresar( ); //operador flecha en vez de operador punto
numero_objeto++;
system("cls");
break;
case 2:
cout <<"\n";
cout<<"------------------------------------------------------"<<endl;
cout<<" LISTADO DE ESTUDIANTES INSCRITOS "<<endl;
cout<<"------------------------------------------------------"<<endl;
for (i=0;i<numero_objeto;i++)
{
cout << "Estudiante numero " << i+1;
cout << ": ";
(p+i) -> mostrar_nombre( );
cout << "\n";
}
cout<<endl;
system("pause");
system("cls");
break;
case 3:
cout << "Ingrese el numero de lista del estudiante a generar el reporte: ";
cin >> n;
if ( n > 0)
{
cout<<"------------------------------------------------------"<<endl;
cout<<" ALUMNO: ";
(p+n-1) -> mostrar_nombre( );
cout<<endl<<endl;
cout<<" NOTAS OBTENIDAS ";
cout << "\n";
(p+n-1) -> reporte( );
cout<<"------------------------------------------------------"<<endl;
}
else
cout<<"Digite un codigo de alumno valido "<<endl;
cout<<endl;
system("pause");
system("cls");
break;
case 4:
break;
 default:
cout<<"\n\n Ingrese una opcion valida del menu.\n";
system("pause");
system("cls");
}
} while (opcion != 4); //sale del programa
delete [ ] p; //libera la memoria asignada a *p
}