1

1 Guía Programación I

Tema: Arreglos de Objetos en C++.

Objetivos Específicos

 Describir la implementación de arreglos de Objetos.

 Implementar programas en C++ que incluyan el uso de Arreglos de Objetos.

Materiales y Equipo

Computadora con el software CodeBlock o DevC++

Introducción Teórica

Arreglo de
objetos.
La función básica de un arreglo es almacenar en una variable más de un valor de un
mismo tipo de dato, por ejemplo la siguiente declaración int numero [5]; permite almacenar
en la variable numero, 5 valores enteros.
En las clases el concepto de arreglos es el mismo, con la diferencia que ahora se
almacenarán objetos de una clase o de diferentes clases.
Los objetos se pueden estructurar como un array. Los objetos son variables y tienen las
mismas capacidades y atributos que cualquier tipo de variables, por tanto es posible
disponer objetos en un array.
La sintaxis es exactamente igual a la utilizada para declarar y acceder al array. También
disponemos de arrays bidimensionales.
Cuando se crea un array de objetos éstos se inicializan llamando al constructor sin
argumentos. Por consiguiente, siempre que se prevea organizar los objetos en un array, la
clase debe tener un constructor que pueda llamarse sin parámetros.
 2 Guía Programación I

La sintaxis para declarar un arreglo de objetos es la siguiente:

<nombre de clase> <nombre del arreglo > [<numero de elementos>];
<nombre_clase> <nombre del arreglo> [<numero de elementos>] = {elementos};

Ejemplo para crear dos objetos de la clase celular:

celular aCell [2];

Inicialización:
nombre del arreglo [índice].función(valores);

Creación de objetos en forma dinámica.

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);

También se pueden crear arreglos de objetos asignados dinámicamente, estos arrays

pueden utilizar la sentencia new.
La sintaxis general es:

DECLARACIÓN DEL ARRAY:

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

puntero = new tipo[tamaño];

Ejemplo de un arreglo creado en forma dinámica:

#include<iostream>

using namespace std;

 3 Guía Programación I

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
system(“pause”);
}

Procedimiento

Ejemplo
1:
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>

using namespace std;

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

class Alumno // Definición de la clase

{ private:
 4 Guía Programación I

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; //Escribe el nombre del alumno en la pantalla
}

void Alumno::reporte() //Genera reporte del estudiante seleccionado

{ 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 //estructura do...while que mantiene en el ciclo principal

{
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

}

Análisis de Resultados

Ejercicio
1:

Tomar el código anterior como referencia y realizar los cambios que sean necesarios para
crear un programa que simule un sistema de control de notas.
Considere que cada alumno puede cursar como máximo 3 asignaturas por ciclo. Para
cada asignatura se deben considerar notas los siguientes porcentajes por período (1º:
30%; 2º: 30% y 3º: 40%).
El programa debe tener un menú con las siguientes opciones:
Opción de menú 1: Ingresar datos de los alumnos y las asignaturas.
Opción de menú 2: Mostrar los datos de un alumno en particular, haciendo uso del miembro “id
carnet”. A partir de los datos introducidos debe mostrarse además, la nota promedio de cada
asignatura, indicar si la materia está “Aprobada” ó “Reprobada”.
Opción de menú 3: Salir del programa.
El menú deberá estar siempre activo, hasta que el usuario seleccione la opción salir.

Investigación Complementaria

1. Investigue cuales son los usos mas comunes de punteros a objetos en C++.
2. Qué es el puntero this. Utilización en C++.
3. Utilidad de las clases amigas en C++. Incluir ejemplos de su uso.