Implementación de POO en C++

POO EN C++
ALCANCE DE CLASES EN C++

Los nombres de variables y los nombres de funciones declarados en una

definición de clase, y los nombres de datos y funciones miembro de una
clase, pertenecen al alcance de dicha clase. Las funciones no miembro se
definen en alcance de archivo.

Dentro del alcance de la clase, los miembros de clase son accesibles de

inmediato por todas las funciones miembro de dicha clase y pueden ser
referenciados sólo por su nombre.

Fuera del alcance de una clase, los miembros de clase se referencian, ya sea
a través del nombre del objeto, una referencia a un objeto, o un apuntador a
un objeto.
POO EN C++
Declaración de Clases

La sintaxis de la declaración de una clase es similar a la de una estructura,

su forma general es:

class nombre-clase {
(private:)
métodos y atributos de la clase;
public:
métodos y atributos públicos de la clase;
}

Para efectos prácticos, un objeto es una variable de un tipo definido por el

usuario, la clase.
POO EN C++
Declaración de Clases

Puede parecer extraño que un objeto que enlaza código y datos se pueda
contemplar como una variable; sin embargo, en C++, este es precisamente el
caso.

Cada vez que se define una nueva clase, se está creando un nuevo tipo de
dato, cada instancia específica de este tipo de dato es una variable
compuesta a la que llamamos objeto.
POO EN C++ class Persona
{
public:
Ejemplos de Declaración
void AsignaNombre(void);
de Clases void IngresaInfo(void);
void MuestraInfo(void);
class Menu void EliminaInfo(void);
{ void GuardaInfo (int registro);
public: void RecuperaInfo (int registro);
int EjecutaMenu(int registro); Persona(void);
Menu(void); ~Persona(void);
~Menu(void); private:
private: int Edad,Numero;
int accion, cualaccion; int CalculaEdad(int anio_nacimiento);
}; int CalculaEdad(string fecha_nacimiento);
int CalculaAnioActual(void);
char Nombre[50], Apellido[50], Calle[50], Colonia[50],
Ciudad[50], Estado[50];
string Nacimiento;
};
POO EN C++
Ejercicio:

En base a las declaraciones de las clases presentadas identifique:

1. En donde podemos identificar elementos del encapsulamiento

2. En donde podemos identificar elementos del polimorfismo / sobrecarga
3. En donde podemos identificar constructores
4. En donde podemos identificar destructores
5. Cuales son los métodos incluidos para cada clase
6. Cuales son los atributos incluidos para cada clase

En el compilador CodeBlocks implemente la declaración de una clase llamada

“Empleado” con la definición de sus elementos (métodos y atributos públicos
y privados, constructor y destructor)
POO EN C++
Ejercicio 2:

En el compilador CodeBlocks cree una clase llamada FichaBib que almacene

una entrada para un catalogo de fichas de biblioteca, la clase debe contener
atributos que almacenen:
Nombre, Autor, Numero de copias, Copias disponibles y Numero de paginas
Métodos para :
Almacenar
Mostrar Datos
Actualizar Existencias
Eliminar
POO EN C++
Encapsulamiento en C++:

En una clase, los datos y el código, o ambos, pueden ser privados para esa
clase o púbIicos.

Las funciones y variables declaradas dentro de una declaración de clase se

dice que son miembros de esa clase, y por omisión, todas las funciones y
variables declaradas en una clase son privadas para esa clase. Esto significa
que sólo son accesibles por otros miembros de esa clase, es decir, una parte
del programa que está fuera del objeto no puede acceder al código o a los
datos privados. Cuando el código o los datos son públicos, partes del
programa ajenos a la clase pueden acceder a ellos.
POO EN C++
Encapsulamiento en C++:

Normalmente, las partes públicas de una clase se utilizan para proporcionar

una interfaz controlada a las partes privadas de la misma.

Para declarar miembros de clase públicos se utiliza la palabra reservada

public, seguida de dos puntos. Todas las funciones y variables declaradas tras
la etiquete public son accesibles tanto por otros miembros de la clase como por
cualquier otra parte del programa que contiene la clase.

En ciertos casos es necesario poder acceder a a determinados miembros de un

objeto de una clase desde otros objetos de clases diferentes sin comprometer
el encapsulamiento, es decir, manteniendo esos miembros como privados.
POO EN C++
Encapsulamiento en C++:

C++ permite hacer esto mediante el uso de las declaraciones amigas (friend), la
sentencia friend se utiliza en clases o métodos para permitir que la clase
amiga acceda a los miembros privados.

La amistad no puede heredarse, es decir si existe una relación de amistad

entre una clase A y una clase B, siendo C es una clase derivada de A, no existe
por definición una relación de amistad entre B y C.

Al establecer una relación de amistad entre una clase A y B, esta no se

comporta de manera bidireccional, es decir que los miembros privados de la
clase B sean visibles a la clase A.
POO EN C++
Ejemplo:
void Numero::mostrar()
{
#include <iostream> cout << "El numero es: " << x << endl;
using namespace std; }
void establecer(double a, Numero &objeto)
class Numero {
{ objeto.x = a; //puede modificar porque es amiga.
friend void establecer(double ,Numero &); }
public:
Numero(double); int main()
void mostrar(); {
private: Numero Pi(7.8);
double x; Pi.mostrar();
}; cout << "Modificamos con la funcion amiga" << endl;
establecer(3.14,Pi);
Numero::Numero(double b) Pi.mostrar();
{ return 0;
x = b; }
}
Ejercicio:
Escriba la definición de una función amiga de la Clase “FichaBib” con la que
pueda modificar los ejemplares disponibles
POO EN C++
Constructores en C++:

Al crear un nuevo objeto a partir de una clase definida es común tener la

necesidad de inicializar valores al interior del mismo, para ello utilizamos los
contructores.

Un método constructor tiene el mismo nombre de la clase de la cual forma

parte y no devuelve ningún tipo de dato, debe ser declarado como publico
porque siempre se utiliza desde el exterior del objeto.

Si una clase posee constructor este será ejecutado cuando se declare un objeto
de esa clase, si no se especifica un método constructor el compilador construye
uno por defecto que no ejecuta ninguna acción
POO EN C++
Constructores en C++:

Ejemplo de un constructor:

Persona::Persona(void)
{
char SinDato[6] = "Vacio";

estableceNombre(SinDato);
estableceApellido(SinDato);
Numero = 0;
strcpy(Calle,SinDato);
strcpy(Colonia,SinDato);
strcpy(Ciudad,SinDato);
strcpy(Estado,SinDato);
estableceDireccion(Calle,Numero,Colonia,Ciudad,Estado);
estableceEdad(0);
}
POO EN C++
Destructores en C++:

El complemento de un constructor es el destructor, el cual se invocará cuando

el objeto se destruya.

Tienen el mismo nombre que la clase que los contiene con el prefijo ~

No devuelven ningún tipo de dato y no pueden ser sobrecargados, al igual que

los constructores deben ser declarados como públicos
POO EN C++
Destructores en C++:

Ejemplo de un destructor:

~Persona(void)
{
delete[] Nombre;
delete[] Apellido;
delete[] Calle;
delete[] Colonia;
delete[] Ciudad;
delete[] Estado;
}

Ejercicio: Escriba el código de un constructor y un destructor para la clase

“FichaBib”
POO EN C++
Tarea

Dado el siguiente programa genere una versión basada en objetos que tenga
una clase “Gato” que ejecute todas los métodos del juego
#include <stdio.h> void DibujaTablero()
#include <stdlib.h> {
system("cls");
char tablero[3][3];
printf("\n\n");
int InicializaTablero() printf(" %c | %c | %c\n", tablero[0][0], tablero[0][1], tablero[0][2]);
{ printf("---|---|---\n");
tablero[0][0] = '1'; printf(" %c | %c | %c\n", tablero[1][0], tablero[1][1], tablero[1][2]);
tablero[0][1] = '2'; printf("---|---|---\n");
tablero[0][2] = '3'; printf(" %c | %c | %c\n", tablero[2][0], tablero[2][1], tablero[2][2]);
tablero[1][0] = '4';
tablero[1][1] = '5'; }
tablero[1][2] = '6';
tablero[2][0] = '7';
tablero[2][1] = '8';
tablero[2][2] = '9';

return 0;
}
POO EN C++
void EjecutaTiro(int jugador, int renglon, int columna) else
{ fflush(stdout);
int tiro; if (tablero[renglon][columna] > '9')
char entrada; printf("Casilla ya ocupada");
}
do while(tiro < 0 || tiro > 9 || tablero[renglon][columna] > '9');
{
printf("\nJugador %d, haga su tiro, indique casilla de las %cs: ", tablero[renglon][columna] = (jugador == 1) ? 'X' : 'O';
jugador,(jugador==1)?'X':'O'); }
scanf(" %c", &entrada);
switch (entrada) { void CalculaGanador(int jugador, int *ganadorRef)
case '1': {tiro = 1; break;} {
case '2': {tiro = 2; break;} int linea;
case '3': {tiro = 3; break;}
case '4': {tiro = 4; break;} if((tablero[0][0]==tablero[1][1] && tablero[0][0]==tablero[2][2])
case '5': {tiro = 5; break;} || (tablero[0][2]==tablero[1][1] && tablero[0][2]==tablero[2][0]))
case '6': {tiro = 6; break;} *ganadorRef = jugador;
case '7': {tiro = 7; break;} else
case '8': {tiro = 8; break;} for(linea = 0; linea <=2; linea++)
case '9': {tiro = 9; break;} if((tablero[linea][0]==tablero[linea][1] &&
default: { tablero[linea][0]==tablero[linea][2])||
printf("\nNo es una casilla valida, repita el tiro: "); (tablero[0][linea]==tablero[1][linea] &&
tiro = -1; tablero[0][linea]==tablero[2][linea]))
} *ganadorRef = jugador;
} }
if (tiro != -1)
{
renglon = --tiro/3;
columna = tiro%3;
}
POO EN C++
void ImprimeGanador(int ganador)
{ DibujaTablero(tablero);
if(ganador==0) ImprimeGanador(ganador);
printf("Empate\n");
else printf("\nQuiere jugar de nuevo (s/n): ");
printf("El ganador es el jugador %d\n", ganador); ciclo = getche();
} system("cls");
}
int main() return 0;
{ }
char tablero[3][3];
int renglon = 0;
int columna = 0;
int ganador = 0;
int jugador = 0;
int indice;
char entrada, ciclo = 's';

while (ciclo == 's' || ciclo == 'S')

{
ganador = InicializaTablero();
for (indice = 0; indice < 9 && ganador == 0; indice++)
{
DibujaTablero();

jugador = indice % 2 + 1;

EjecutaTiro(jugador,renglon,columna);
CalculaGanador(jugador,&ganador);
}
POO EN C++
Herencia en C++:

La herencia, entendida como una característica de la programación orientada a

objetos, concretamente en C++ permite definir una clase modificando una o
más clases ya existentes.

Estas modificaciones consisten habitualmente en añadir nuevos miembros

(variables o funciones), a la clase que se está definiendo, aunque también se
pueden redefinir variables o funciones miembro ya existentes.

La clase origen recibe el nombre de clase base, y la nueva clase que se obtiene
se denomina clase derivada.
POO EN C++
Herencia en C++:

Una clase derivada puede a su vez ser clase base a una segunda clase derivada,
generando lo que se conoce como jerarquía de clases. Normalmente las clases
base suelen ser más generales que las clases derivadas.

Ejemplo:
Persona

Empleado Empleador

Secretario Cajero Vigilante

POO EN C++
Herencia en C++:

Para declarar una clase derivada de una clase previamente definida se utiliza la
siguiente
sintaxis:

class Base
{
… // Declaración de atributos y métodos de la clase Base
};

class Derivada : public Base

{
… // Declaración de atributos y métodos de la clase Derivada
};
POO EN C++
Herencia en C++:

La herencia puede efectuarse de dos maneras: siendo la clase base publica o

privada para la clase derivada.

En el caso de que la clase base sea public para la clase derivada, ésta heredara
los miembros public y protected de la clase base como miembros public y
protected, respectivamente.

En el caso ejemplo con la palabra reservada public en el encabezado de la

declaración de la clase “Derivada” se hace referencia a que dicha clase hereda
los atributos y métodos de la clase “Base” en forma publica.
POO EN C++
Herencia en C++:

Cuando la clase base es private para la clase derivada, ésta heredara todos los
datos de la clase base como private.

En principio una clase derivada no puede acceder a los datos privados de la

clase base, pero para hacer posible esto, existe el tipo de dato protected. Este
tipo de datos es privado para todas aquellas clases que no son derivadas, pero
público para una clase derivada de la clase en la que se ha definido la variable
como protected.
POO EN C++
Herencia en C++:

Ejemplo:
class Base
{ private:
// Miembros declarados en la sección privada: accesibles sólo para miembros de esta clase
protected:
/* Miembros declarados en la sección protegida: accesibles sólo para miembros de esta
clase y de sus derivadas */
public:
// Miembros declarados en la sección pública: accesibles para todos
};
POO EN C++
Herencia en C++:

La declaración del constructor en una base derivada debe incluir un llamado al

constructor de la clase base.

Una clase puede heredar variables y funciones miembro de una o más clases
base. En el caso de que herede los miembros de una única clase se habla de
herencia simple y en el caso de que herede miembros de varias clases base se
trata de un caso de herencia múltiple.

Base 1 Base 2

Derivada
POO EN C++
Herencia en C++:

Para definir una relación de herencia múltiple se utiliza la siguiente sintaxis:

class Base1
{ // Declaración de atributos y métodos de la clase Base1
};
class Base2
{ // Declaración de atributos y métodos de la clase Base2
};
class BaseN
{ // Declaración de atributos y métodos de la clase BaseN
};

class Derivada : public Base1, public Base2, public BaseN

{ // Declaración de atributos y métodos de la clase Derivada
};
POO EN C++
Herencia en C++:

Ejercicio:

Genere una clase “FichaHemerog” derivada publica de la clase FichaBib, donde

se especifiquen atributos acordes a una ficha hemerográfica, heredando los
comunes a la ficha bibliográfica
POO EN C++
Sobrecarga/Polimorfismo en C++:

En C++ es posible usar un nombre de función para propósitos muy diferentes, a

esto se llama sobrecarga de funciones.

De forma general, el concepto de polimorfismo es la idea de «una interfaz,

múltiples métodos». Esto significa que es posible diseñar una interfaz genérica
para un grupo de actividades relacionadas, sin embargo, la acción específica
ejecutada dependerá de los datos.
POO EN C++
Sobrecarga/Polimorfismo en C++:

Es muy fácil sobrecargar una función: simplemente hay que declarar y definir
todas las versiones requeridas para un método.

El compilador seleccionará automáticamente la versión correcta para llamar,

en base al número y/o tipo de argumentos usados al invocar el método. En el
ejemplo del valor absoluto, se puede corregir esta situación
sobrecargando un nombre para los tres tipos de datos.
POO EN C++
Sobrecarga/Polimorfismo en C++:

Ejemplo
void NombreClase::ImprimirMensaje(void)
{
cout << "\n Esta es la función sin argumentos";
}
void NombreClase::ImprimeMensaje(char *texto)
{
cout << "\ n Esta es la función con argumentos y ha recibido el mensaje " << texto;
}

Ejercicio: Declare una clase “Absoluto” que contenga 3 versiones

sobrecargadas del método vAbs() para obtener el valor absoluto de un dato de
entrada, las versiones deben aceptar enteros, enteros largos y dobles (abs(),
labs() y fabs())
POO EN C++
Sobrecarga/Polimorfismo en C++:

El polimorfismo también se puede implementar al tener métodos sobrecargados

en clases derivadas. En este caso los métodos de la clase padre se definen
como virtuales ya que no serán usados por las clases derivadas.

Cuando se hace referencia a un objeto de clase derivada mediante un

apuntador o una referencia a la clase base, se puede llamar a una función
virtual para ese objeto ejecutando la versión de la clase derivada de la
función.

Las funciones virtuales garantizan que se llame a la función correcta para un

objeto, con independencia de la expresión utilizada para llamarla.
POO EN C++
Sobrecarga/Polimorfismo en C++:

Si una clase base contiene una función declarada como virtual y una clase
derivada define la misma función. La función de la clase derivada se invoca
para los objetos de la clase derivada, aunque se llame mediante un puntero o
una referencia a la clase base.

Considere el siguiente ejemplo, en donde se llama a un método sobrecargado a

través de una clase base:
POO EN C++
#include <iostream>
using namespace std;

class Cuenta {
public:
Cuenta( double d ) { balance = d; }
virtual double ObtieneBalance() { return balance; }
virtual void ImprimeBalance() { cerr << "Error. Balance no disponible." << endl; }
private:
double balance;
};

class CierreCuenta : public Cuenta {

public:
CierreCuenta(double d) : Cuenta(d) {}
void ImprimeBalance() { cout << “Balance al cierre: " << ObtieneBalance() << endl; }
}; int main() {
CierreCuenta *pCierre = new CierreCuenta( 100.00 ) ;
class AhorroCuenta : public Cuenta { AhorroCuenta *pAhorro = new AhorroCuenta( 1000.00 );
public:
AhorroCuenta(double d) : Cuenta(d) {} Cuenta *pCuenta = pCierre;
void ImprimeBalance() { cout << “Balance de ahorro en cuenta: " << ObtieneBalance(); } pCuenta->ImprimeBalance();
};
pCuenta = pAhorro;
pCuenta->ImprimeBalance();
}
POO EN C++
Sobrecarga/Polimorfismo en C++:

Ejercicio:

Genere métodos sobrecargados para Almacenar y Mostrar Contenido en la clase

FichaHemerog para que almacenen y muestren información hemerográfica
virtualizando los métodos de la clase FichaBib
POO EN C++
Apuntadores a clases

Un apuntador puede señalar cualquier tipo de “variable” en C++, incluyendo

clases, cuando tenemos una apuntador a una clase tenemos un “generador
dinámico” de objetos, la sintaxis al igual que con el resto de las variables usa
el * para indicar que se trata de un apuntador a una clase

Un apuntador a una clase puede se eterno a la clase o ser un atributo al

interior de la misma con lo que podemos generar colas y listas de manera
dinámica

Ejemplo
POO EN C++
Ejemplo, considere la siguiente clase:
POO EN C++
Apuntadores a clases

Podemos apreciar que tenemos atributos que apuntan a la misma clase

(apAnterior y apSiguiente) y métodos que también devuelven un apuntador a la
misma clase (LeeAnterior y LeeSiguiente), es a través de estos métodos y
atributos podemos construir una lista dinámica de objetos de la clase Libro

Cuando queremos crear dinámicamente un objeto de la clase Libro a través de

un apuntador utilizamos la sentencia new, ejemplo:

Esta sentencia generará un nuevo objeto de la clase libro invocando a su

constructor
POO EN C++
Apuntadores a clases

Cuando un objeto debe dejar de existir dentro del programa lo podemos

eliminar con la sentencia delete que lo borra e invoca adicionalmente a su
destuctor

Nótese que eliminamos a través del apuntador, nunca con una referencia al
objeto o a la clase

Cuando tenemos objetos referenciados a través de su apuntador no usamos el .

(punto) para acceder a los miembros del objeto sino a través de ->
POO EN C++
Apuntadores a clases

Ejemplo:
POO EN C++
Apuntadores a clases

Adicionalmente podemos usar el referenciador -> en cuantos niveles se

requiera cuando hay apuntadores adentro de la clase apuntada, ejemplo:
POO EN C++
Apuntadores a clases

Los apuntadores se pueden heredar, es decir si declaramos un apuntador a una

clase padre también podemos usarlo para referencias una clase derivada, pero
existirán restricciones a considerar
POO EN C++
Ejemplo: Considere el siguiente código
#include <iostream>

using namespace std;

class Persona
{
string Nombre, Apellido, Direccion;
int Edad;
public:
Persona(string lNombre, string lApellido, string lDireccion, int lEdad);
void MuestraDatosPersona(void);
};

Persona::Persona(string lNombre, string lApellido, string lDireccion, int lEdad)

{
Nombre=lNombre;
Apellido=lApellido;
Direccion=lDireccion;
Edad=lEdad;
};

void Persona::MuestraDatosPersona(void)
{
std::cout << "La persona es: " << Nombre << " " << Apellido << std::endl;
std::cout << "Que vive en: " << Direccion << std::endl;
std::cout << "Actu" << char(160) << "lmente tiene: " << Edad << " a" << char(164) << "os de edad" << std::endl;
};
POO EN C++
Ejemplo: Considere el siguiente código
class Alumno : public Persona
{
int Boleta;
public:
Alumno(string lNombre, string lApellido, string lDireccion, int lEdad, int lBoleta) : Persona(lNombre, lApellido, lDireccion, lEdad)
{
Boleta=lBoleta;
};
int MuestraBoleta(void);
};

int Alumno::MuestraBoleta(void)
{
std::cout << "La boleta del alumno es: " << Boleta << std::endl;
};

int main()
{
Persona *apPersona;
Alumno *apAlumno;

Persona juan("Juan","Perez","Av. Politecnico No 30",20);

Alumno jose("Jose","Lopez","Av. Revolucion 1200 piso 6",21,17082278);

std::cout << "LA PRIMERA PARTE SE HACE CON LOS OBJETOS DIRECTAMENTE: " << std::endl << std::endl;
std::cout << "Los datos de la primer persona que no es alumno leidos directamente del objeto son: " << std::endl;
juan.MuestraDatosPersona();
std::cout << std::endl;
std::cout << "Los datos de la segunda persona que es alumno leidos directamente del objeto son: " << std::endl;
POO EN C++
Ejemplo: Considere el siguiente código
jose.MuestraDatosPersona();
jose.MuestraBoleta();
std::cout << "____________________________________________________________________________________" << std::endl;

std::cout << "LA SEGUNDA PARTE SE HACE A TRAVES DE LOS APUNTADORES: " << std::endl << std::endl;
apPersona=&juan;
apAlumno=&jose;
std::cout << "Los datos de la primer persona que no es alumno leidos mediante el apuntador son: " << std::endl;
apPersona->MuestraDatosPersona();
std::cout << std::endl;
std::cout << "Los datos de la segunda persona que es alumno leidos mediante el apuntador son: " << std::endl;
apPersona->MuestraDatosPersona();
apAlumno->MuestraBoleta();
std::cout << "____________________________________________________________________________________" << std::endl;

std::cout << "LA TERCERA PARTE SE HACE EN FORMA DINAMICA CREANDO OBJETOS A TRAVES DE LOS APUNTADORES: " << std::endl << std::endl;
apPersona=new Persona("Maria","Juarez","Independencia 25, Col. Centro",21);
apAlumno=new Alumno("Sandra","Gomez","Añil 73, 4to piso, Col. del Valle",19,17084726);
std::cout << "Los datos de la primer persona que no es alumno generados mediante el apuntador son: " << std::endl;
apPersona->MuestraDatosPersona();
std::cout << std::endl;
std::cout << "Los datos de la segunda persona que es alumno generados mediante el apuntador son: " << std::endl;
apPersona->MuestraDatosPersona();
apAlumno->MuestraBoleta();
std::cout << "____________________________________________________________________________________" << std::endl;

return 0;
}
POO EN C++
Apuntadores a clases

La generación de una lista dinámica de objetos considera que debemos tener

siempre un apuntador al inició de la lista y que la estructura de la clase debe
incluir apuntadores al objeto anterior y al siguiente.

Cuando se integra el primer nodo tanto el anterior como el siguiente apuntan a

nullptr, cada que se agrega un nuevo nodo se asigna al apuntador siguiente del
ultimo nodo existente al nuevo nodo que se agrega y el apuntador anterior del
nuevo nodo al ultimo existente y el siguiente a nullptr.

C++ nos brinda una clase de objetos “lista” a través de la librería list que nos
facilita la programación de las mismas
POO EN C++
Clase List

Considere el siguiente ejemplo:

#include <iostream> int Numero::LeeDato()
#include <list> {
return Dato;
using namespace std; };

class Numero list <Numero> Numeros;

{ list <Numero> :: iterator Recorre;
int Dato;
public: int main()
void IngresaDato(int); {
int LeeDato(); int i,j,Leido;
}; char continua;

void Numero::IngresaDato(int Entrada) Numero *apNodo;

{
Dato = Entrada;
};
 i=1;

POO EN C++
do
{
apNodo = new Numero;

std::cout << endl << "Ingrese numero " << i << ": ";
std::cin >> Leido;
apNodo->IngresaDato(Leido);
Numeros.push_back(*apNodo);
i++;

std::cout << endl << "Impresion de resultados:" << endl;

j=1;

Recorre = Numeros.begin();
while (Recorre != Numeros.end())
{
if (j%6 == 0)
std::cout << endl;
std::cout << "\tNo. " << j << ": " << Recorre->LeeDato();
Recorre++;
j++;
};

std:cout << endl << "Deseas continuar (s/n): ";

std::cin >> continua;

}
while(continua != 'N' && continua != 'n');
}
POO EN C++
Listas Dinámicas

Proyecto:

Elabore la programación para generar listas dinámicas de objetos alineados con

su proyecto final.