UCSM Esc. Prof.

de Ingeniería de INFORME DE PRÁCTICAS

Sistemas

ABRIL- 2021 LENGUAJES DE

PROGRAMACIÓN II

Práctica N° 03
Elaborado por:
a) Nombre y Código
b) Carlos Elisban Huaman Quispe 2020243481
c) Maria Fernanda Huarcaya Quispe 2020243642
d) Bryan Carlos Tarqui Gomez 2017826151

© IEEE 2013 The Institute of Electrical and Electronics Engineers, Inc.

Práctica N° 2: Abstracción, Métodos,Mensajes, Encapsulamiento en C++

ii
Práctica N° 2: Abstracción, Métodos,Mensajes, Encapsulamiento en C++

GRUPO N° 3

PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN II

Presentado por:

- Carlos Elisban Huaman Quispe 2020243481

- Maria Fernanda Huarcaya Quispe 2020243642
- Bryan Carlos Tarqui Gomez 2017826151
Práctica N° 2: Abstracción, Métodos,Mensajes, Encapsulamiento en C++

RECONOCIMIENTOS

El autor de este trabajo reconoce con gratitud a los creadores de los lenguajes C, C++ y
otras personalidades y autores de libros de programación Bjarne Stroustrup, Dennis
Ritchie, Herb Sutter, Herb Sutter, James Gosling, James Gosling, Brian Kernighan, Brian
Kernighan, Ken Thompson.

PALABRAS CLAVES

Diseño de clases, Constructores, Destructores, Auto referencias, herencia

Práctica N° 2: Abstracción, Métodos,Mensajes, Encapsulamiento en C++

ÍNDICE

1. RESUMEN……………………………………………………………………………………………………7
2. INTRODUCCION……………………………………………………………………………………………7
3. MARCO TEORICO……………………………………………………...................................................8
3.1 Clases……………………………………………………………………………………………………8
3.2 Accesos especificados………………………………………………………………………………...9
3.3 Abstracción……..……………………………………………………………………………………….10
3.4 Encapsulamiento………………………………………………………………………………………..11
3.4.1 Constructores……………………………………………………………………………………..12
3.4.2 Destructores……………………………………………………………………………………….13
4. MODELAMIENTO…………………………………………………………………………………………...14
5. EXPERIENCIAS PRACTICAS……………………………………………………………………………..14
6. CONCLUSIONES DE LA PRACTICA……………………………………………………………………..21
7. CUESTIONARIO…………………………………………………………………………………………….21
8 BIBLIOGRAFIA………………………………………………………………………………………………23
8.1 De la introducción……………………………………………………………………………………….23
8.1.Del cuestionario…………………………………………………………………………………………23
8.2 Del Marco teórico………………………………………………………………………………………..23
25
Práctica N° 2: Abstracción, Métodos,Mensajes, Encapsulamiento en C++
 Práctica N° 9: Manejo de Excepciones

1. RESÚMEN

En esta práctica se abarcara tres temas importantes, para desarrollar en el ámbito de la programación,
específicamente en el lenguaje de C++. El primer tema tiene como nombre “Diseño de clases”, este tema
abarca las relaciones que tienen un objeto con otro. Estas relaciones son muy variadas ya que pueden ser n-
arias, binarias, reflexivas, dependiente, de herencia o de agregación. El segundo tema son las auto-
referencias, pero para conocer mejor este tema, debemos recordar definiciones previas como el puntero y
sus usos dentro de una clase. Por último tenemos el tema de “Los constructores y Destructores”, es en este
tema donde la construcción de nuestra clase evitara ser errónea ya que los compiladores hacen uso de los
constructores. Caso contrario los destructores, son el otro lado de la moneda ya que nos permite eliminar
correctamente valores dentro de la clase.

2. INTRODUCCIÓN
En este punto se abordará sobre lo que es diseño de clases, por ser importantes para diseñar un programa
orientado a objetos, uno de los tipos de diagrama de clases más utilizados en el diseño de sistemas es UML,
un diagrama de clases nos permite diseñar un diagrama principal y trazar muy definido la estructura de un
sistema, si queremos modelar una clase, atributos, operaciones y relaciones entre objetos.
Los diagramas de clases son los más importantes en el desarrollo del software porque allí se definen como
están relacionados los módulos que se van a elaborar, es lo primero que se debe hacer antes de desarrollar el
software. Estos diagramas son utilizados principalmente en la programación orientada a objetos.1
los diagramas de clases son un tipo de diagrama de estructura porque describen lo que debe estar presente en
el sistema que se está modelando.
En UML existen varios tipos de clases, para modelar una clase es importante definir, analizar la situación
problemática a resolver, porque de esto depende el funcionamiento del software.
En la programación orientada a objetos un constructor “es un constructor es un método que tiene el mismo
nombre de la clase y que tiene el propósito de inicializar los atributos y variables cuando se instancia la
clase”2
El propósito de un constructor es inicializar un objeto, los atributos y variables cuando este es creado. Una
clase puede tener varios constructores, según a la cantidad y tipo de datos.
Los destructores son lo opuesto a los constructores. “Un destructor en algunos lenguajes de programación
orientados a objetos es un método de una clase que se llama justo antes de una instancia de esa clase y se
elimina de la memoria. No todos los lenguajes de programación orientados a objetos suelen tener un
destructor.”3
Un destructor en algunos lenguajes de programación orientados a objetos es un método de una clase que se
llama justo antes de una instancia de esa clase y se elimina de la memoria. No todos los lenguajes de
programación orientados a objetos suelen tener un destructor. El uso más frecuente de un destructor es liberar
memoria que fue asignada por el constructor.4

1
Nathaly Alva, 2015. Diagrama de clases
2
Ing. Alvaro Enrrique Ruano. Programación orientada a objetos.
3
Programación Gerardo. constructores y destructores - programacion Gerardo (google.com)
4
Ing. Alvaro Enrrique Ruano. Programación orientada a objetos.
Programación Orientada a Objetos - constructores y destructores (slideshare.net)
7
Práctica N° 2: Abstracción, Métodos, Mensajes, Encapsulamiento en C++

3. MARCO TEÓRICO
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
ES? USO?
Herencia Simple
La herencia es una cualidad Se declara con la palabra clave Un breve ejemplo de la herencia Cuando las características de los
clave en la programación de que sería Class (clase derivada): La clase gato deriva de la clase base objetos son dadas por la
orientación de objetos en public (clase base): que es animal y los miembros de descripción de la clase[1]
C++.[1] animal son accesibles a gato.
Class Animal {
Este nos permite crear una // void comer ()
clase derivada este adquiere // void dormir ()
las propiedades y la // void respira ()
funcionalidad de una clase };
ya existente que sería la Class gato: public Animal {
clase base. [1] // void maullar ()
};

Herencia Múltiple #include <iostream> Cuando al llamar un método y el

Es cuando la clase derivada Se declara con la palabra clave using namespace std; compilador no puede determinar
tiene mas de una clase base. que sería Class (clase derivada): class mamifero { que método de clase debe
[2] public (clase base), public (clase public: llamar. [2]
base) mamifero(){
cout<<"La gran cantidad de
En el ejemplo trata de un ejemplo mamiferos son viviparos " << endl;}
de herencia de múltiples. };
La clase murciélago se deriva de class volador {
las clases bases que son mamífero public:
y volador además la clase volador (){
murciélago es un mamífero y cout<<"El animal volador puede
volador. volar " << endl;}
};
class mucielago:public,
mamifero,public volador {};
int main(){
mucielago b1;
return 0;}
1
3.1 Herencia Simple y herencia múltiple
3.1.2 Herencia jerárquica
¿QUÉ
ES?
En esta a diferencia de la
clase múltiples contiene
solo una clase base y tiene
más de una clase derivada.
[3]
¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
USO?
Se declara con la palabra clave #include <iostream> Cuando varias clases derivan de
que sería Class (clase base) { using namespace std; una sola clase base, esto hace
} // Este es la clase base(class animal) que usemos la herencia
class Animal {
Class (Primera clase derivada): public:
jerárquica. [3]
public (clase base) { void dato() {
} cout << "Es un animal" << endl;}
Class (Segunda clase derivada): };
public (clase base) { // Este es la primera clase derivada (class
} Perro)
Y así sucesivamente. class Perro : public Animal {
public:
void ladrar () {
En este ejercicio las clases cout << "Es un perro y ladra " <<
derivadas son Perro y León y la endl;}
clase base es el animal donde las };
dos clases pueden acceder al dato // Este es la segunda clase derivada (class
función que le pertenece a la clase Leon)
base. class Leon: public Animal {
public:
void ruge () {
cout << "Es un leon y ruge " << endl;}
};
int main() {
// Se crea un objeto de la clase Perro
Perro P1;
cout << "Clase Perro :" << endl;
P1.dato(); // Este es la funcion de la clase
base
P1.ladrar();
// Se crea un objeto de la clase Perro
Leon L1;
cout << "\nClase Leon :" << endl;
L1.dato(); // Este es la funcion de la clase
base
L1.ruge();
return 0;
}
1
3.1.3 Tipos de herencia
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
ES? USO?
Herencia Privados Para la herencia de privados la Sintaxis Lo usamos en la clase sino no se
Cuando esta derivada de la palabra clave PrivateDerived[4] Class PrivateDerived: public (clase puede acceder fuera la clase. [4]
clase base privada hace que base) {
otros miembros ya sea }
públicos y protegidos se
conviertan en solo
miembros privados de la
clase derivada.
[4]

Herencia Públicos Para la herencia de punlico la Sintaxis Lo usamos en la clase ya se

Cuando esta derivada de la palabra clave PublicDerived[4] Class PublicDerived: public (clase dentro o fuera de la clase a
clase base publica los base) { través del objeto y el operador
miembros de la clase se } de punto. [4]
convierten en públicos de la
clase derivada. [4]

Herencia Protegidos Para la herencia de protegido la Sintaxis Lo usamos cuando solo

Cuando esta derivada de la palabra clave ProtectDerived[5] Class ProtectDerived: public (clase queremos que se no se acceda a
clase base es protegida los base) { una clase[5]
convierten en protegido sus }
miembros de la clase deriva.
[5]

1
3.2 Constructores
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
ES? USO?
Estos juegan un papel Cuando se defina el cuerpo del Este es la clase podemos ver como se
importante en la creación de constructor usamos el parámetro usa la constructor Se usa para inicializar los
objetos y la inicialización de para inicializar el objeto. [4] #include <iostream> miembros de datos y construir el
las variables de instancia. using namespace std; objeto de la clase. El compilador
[5] class Ejemplo lo llama automáticamente
{ cuando se crea el objeto.[4]
Es una función miembros de public:
una clase que inicializa int a = 10;
objetos de una clase. [5] ~Ejemplo() // Destructor
{
El constructor cuando se cout << "Ejem del destructor"
crea un objeto. Es una << endl;
función miembro especial
de la clase. }
void imprimi_Ejemplo() //
Los constructores tienen el función
mismo nombre de la clase {
[5] cout << "Imprime ejem" <<
endl;
El constructor es llamado
automáticamente después de }
crear el objeto.[5] };

No tienen tipo de retorno y int main()

es una función pública de {
clase. Ejemplo E1; // el objeto de clase
ejemplo creado//
cout << E1.a << endl;
E1.imprimi_Ejemplo(); //función
llama
return 0;
}

1
3.2.1 Destructores
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
ES? USO?
La función miembro Este debe declararse en la sección Este es un ejemplo de destructor El compilador crea un destructor
destructor elimina un objeto publica de la clase.[6] #include <iostream> cuando asignamos memoria o
y este se llama using namespace std; puntero en la clase.[6]
automáticamente cuando se El nombre siempre debe class Ejemplo
destruye.[6] comenzar con el signo (~) y este { Lo usamos cuando queremos
debe coincidir con el nombre de la public: destruir los objetos que fueron
El destructor no tiene clase. int a = 10; creados por los constructores.[6]
argumentos y ningún tipo de ~Ejemplo() // Destructor
devolución ni siquiera nulo. {
cout << "Ejem del destructor"
El programador no puede << endl;
acceder a la dirección del
destructor.[6] }
void imprimi_Ejemplo() //
Destructor no acepta ningún función
argumento ni devuelve {
ningún valor. [6] cout << "Imprime ejem" <<
endl;
Este libera la memoria para
su uso posterior. }
};

int main()
{
Ejemplo E1; // el objeto de clase
ejemplo creado//
cout << E1.a << endl;
E1.imprimi_Ejemplo(); //función
llama
return 0;
}

1
3.3 THIS puntero
¿QUÉ ES? ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
USO?
Cada objeto obtiene su propia This es una palabra clave que Este es un ejemplo de referencia y nos Lo usamos para pasar el objeto
copia de los miembros de datos nos referimos a la instancia de muestra los resultados. como parámetro a otro método.
y comparten una copia de las una clase. [7] #include <iostream> [7]
funciones de los miembros.[7] using namespace std;
class Empleado{ Para hacer una referencia a la
Este tiene un acceso total a la public: variable de instancia de le clase.
misma definición de la función int ID; //miembros de datos
que esta presenta en el código. string nombre; //miembros de También se usa para declarar
[7] datos indexadores. [7]
float salario;
El this es un puntero que pasa Empleado(int ID, string nombre,
un argumento oculto a todas las float salario)
llamadas a funciones miembros {
y esta disponible como una this->ID = ID;
variable local dentro del cuerpo this->nombre = nombre;
de las funciones.[7] this->salario = salario;
}
void D()
{
cout<<ID<<" "<<nombre<<"
"<<salario<<endl;
}
};
int main(void) {
Empleado E1
=Empleado(20205487, "Paco",
25000); //Creando un objeto de
empleado
Empleado
E2=Empleado(202078451, "Julia",
25050); //creating an object of
Employee
E1.D();
E2.D();
return 0;
}
1
3.4 Referencia
¿QUÉ ES? ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
USO?
Al usar las referencias en c++ Cuando una variable se declara Este es un ejemplo de referencia y nos Lo usamos para cambiar las
es similar al usar punteros referencias y este se convierte muestra los resultados. variables locales de una función
constantes.[8] en un nombre alternativo para dentro de otra función.[8]
una variable existente. [8] #include <iostream>
Las referencias no pueden ser using namespace std; Lo usamos también para
nulas. Este debe inicializarse int main () { modificar los parámetros
cuando se declara y este no // Aca declaramos simples variables pasados en una función ya que si
existen restricción con int a; una función recibe una
punteros.[8] double b; referencia a una variable.[8]

Estos no pueden usarse para // Aca declaramos referencias

implementar estructuras. variables
Además, este es más fácil de int& c = a;
usar ya que no necesitan un double& d = b;
operador de des referenciación a = 456;
para poder acceder un valor. Se cout << "El valor de a : " << a <<
puede utilizar como variables endl;
normales.[8] cout << "El valor de referencia: " <<
c << endl;
b = 25.54;
Se puede usar el nombre de la cout << "El valor de : " << b <<
variable o de la referencia para endl;
hacer referencia a la variable. cout << "El valor de referencia: " <<
[8] d << endl;
return 0;
}

1
3.5 Diagrama de clases
¿QUÉ ¿COMO SE DECLARA? EJEMPLO ¿CUÁNDO LO USO?
ES?
Es un como un plano que es El diagrama de clase se declara Cuando queremos modelar un
utilizado para crear un con gráficos que veremos mucho código de clase, modelo de
objeto o conjunto de objetos mejor en el ejemplo. negocios y etc. [9]
y la clase define lo que
puede hacer un objeto.[9] Este se utiliza también para
poder construir un código a
Los diagramas de clases nos través con diagramas.[9]
brindan el poder crear
modelos con la ayuda del Mostrar la colaboración de los
UML elementos y describir las
funciones que realiza este.[9]
Describen un sistema
ilustrando operaciones,
atributos, visualizar,
especificar, construir,
documentar y las relaciones
entre las clases.[9]

Implementa OOP como un

concepto que se usa
suficientemente y reduce la
explicación en una simple
diagramas graficas que es
más fácil de poder
entenderlo.[9]

Se basan en los principios

de la orientación de objetos
y puede implementar varias
fases de un proyecto.[9]

1
 Práctica N° 2: Manejo de Excepciones

4. MODELAMIENTO

5.EXPERIENCIAS DE PRÁCTICA
/ exp practicas.cpp : Este archivo contiene la función "main". La ejecución del programa comienza y
termina ahí.
//
#include <iostream>
#include<conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

void SetColor(int);
void tituloPrincipal();

using namespace std;

int main()
{
string v;
int opc, OpcionVentas, OpcionProveedor, OpcionEnvios;

bool sistem = true;

do {
system("cls");

bool Valor = true;

cout << "\n\t[1] Registro de Pedidos" << endl;
cout << "\n\t[2] Proveedores" << endl;
cout << "\n\t[3] Administrar el Envio de Los Pedidos" << endl;
cout << "\n\t[4] Salir" << endl;

1
6
 Práctica N° 2: Manejo de Excepciones
do {
cout << "\n\tIngrese la opcion: ";
cin >> opc;
} while (opc != 1 && opc != 2 && opc != 3 && opc != 4);
switch (opc) {
case 1:
SetColor(6);
cout << "\n\t[2] Prueba 1" << endl;
break;
case 2:
SetColor(6);
tituloPrincipal();
SetColor(11);
cout << ("\t\t PROVEEDORES\n");
cout << "\n\t[1] Agregar Proveedor" << endl;
cout << "\n\t[2] Todos los Proveedores" << endl;
cout << "\n\t[3] Buscar Proveedor" << endl;
cout << "\n\t[4] Salir del menu" << endl;
system("PAUSE");
break;
case 3:
cout << "\n\tSaliendo del menu principal..." << endl;
break;

case 4:
cout << "\n\tSaliendo del menu principal..." << endl;
sistem = false;
break;

} while (sistem != false);

system("PAUSE");
return 0;

void tituloPrincipal()
{
SetColor(10);
int i;
cout << ("\n ======================================================================\n");
cout << ("\t\t\t SISTEMA DE DELIVERY DelyAir\n");
cout << ("\t\t Copyright 2020 | Lenguajes de Programacion II\n");
cout << (" ======================================================================\n");
i = 0;
putchar('\n');
for (; i < 80; i++) {
putchar('_');
}
}
void SetColor(int ForgC)
{
WORD wColor;
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (GetConsoleScreenBufferInfo(hStdOut, &csbi))
{
wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);
SetConsoleTextAttribute(hStdOut, wColor);
}
return;

1
7
 Práctica N° 2: Manejo de Excepciones
}

#include<iostream>
using namespace std;

class NewClass
{
int x;
public:
NewClass(int _x) { this->x = _x; }
~NewClass();
};

NewClass::~NewClass() { cout << "Ejecutando destructor...obj" << x << endl; }

NewClass obj1(1); //Objeto de alcance global

int main()
{
NewClass obj2(2); //Objeto de alcance local
NewClass obj3(3); //Objeto de alcance local
return 0;

1
8
 Práctica N° 2: Manejo de Excepciones

6. CONCLUSIONES DE LA PRÁCTICA:
En conclusión, estos temas ayudan a organizar mejor una clase tanto al momento de planificar como
ejecutar. Esto se puede ver reflejado cuando se diseña una clase, puesto que permite organizar cada clase y
sus relaciones que existen, así uno al momento de codificar el programa, ya tiene más facilidad. En cambio,
los constructores y destructores ayudan a que los valores que se otorgan a las variables sean con más
fluidez y permite que haya más organización.

En conclusión, la herencia es muy importante en la programación de orientado de objetos y a la vez la

herencia de jerarquía. Pudimos ver en esta práctica que tenemos diversas clasificaciones de herencia como
la herencia simple, herencia jerarquías y entre otros más. También pudimos apreciar que la herencia tiene
tipos como las clases (Públicos, privados y protegido)

En conclusión, los diagramas de clases son útiles para modelar los datos, los atributos de clase se asignan a
métodos de acceso abstractos para campos de relación. Determina si los métodos de acceso a relaciones
aparecen en ambos o solo en uno.

7. CUESTIONARIO
1. ¿Qué es un puntero?

1
9
Práctica N° 2: Manejo de Excepciones
Un puntero es una variable que almacena la dirección de otra variable. Usualmente el nombre de la
variable es declarado junto a un (*).
2. ¿Qué es una referencia?
Son recursos que tienen como objetivo convertir los objetos a parámetros de métodos y valores de
retorno. La forma más usual de declarar una referencia es colocando un “&” al nombre que se le
otorgó a la referencia.
3. ¿Qué es una autorreferencia?
Es un recurso, que suele ser empleado para encadenar los métodos, para que de esta manera la
ejecución se realice por un conjunto de métodos.
4. ¿Cómo se usan las referencias a objetos?
Se utilizan para instanciarlas a una clase, de esta manera podrá dar valores a los atributos. Esto sirve
para que nuestro objeto, directamente pueda incluirse en una clase, pese a que sus atributos sean
privados.
5. ¿Por qué tenemos que usar referencias?
Usualmente las referencias son utilizadas para ver la ubicación de una variable, por ende, casi siempre
trabaja con un puntero, puesto que este es capaz de almacenar una dirección.
6. ¿Por qué tenemos que usar auto referencias?

Si el código emplea bastantes métodos, es necesario usar auto referencias para estos estén encadenados
y la ejecución sea secuencial
7. ¿Qué es el puntero implícito this?
Es un puntero, que se declara dentro de una clase, esto permite que se pueda realizar referencias al
objeto la cual envía mensajes y así se ejecute el método.
8. ¿Cómo se usa el puntero implícito this?
Se usa mediante los métodos, no es obligatorio colocarlo ya que no altera el resultado de la ejecución
del programa.
9. ¿Por qué tenemos que usar el puntero implícito this?
Usualmente se debe utilizar para esquemas de clases en donde es importante encadenar métodos y asi
los valores de retorno posean una referencia con el objeto.
10. ¿Cuáles son los tipos de clases de almacenamiento?
Existe 6, pero las más importantes son dinámico, convencional y automático
11. ¿Qué es un puntero?
Es una variable la cual usamos para definir la dirección de memoria de un objeto.
12. ¿Qué es una referencia?
Una referencia es conocida como un alias o sobrenombre de una variable.
13. ¿Qué es una autorreferencia?
Es la interacción que tiene un objeto de una clase para almacenar una referencia a otros objetos de su
misma clase.
14. ¿Cómo se usan las referencias a objetos?
Se usan mediante el operador de referencia (&) además se usa para declarar a los objetos como
referencias y se usa para dar los parámetros en funciones de referencias.
15. ¿Por qué tenemos que usar referencias?
La referencia nos permite pasar un objeto con la idea de que lo que pasamos es un valor.
16. ¿Por qué tenemos que usar auto referencias?

Para que la implementación de las estructuras de datos de las subsecuentes pueda almacenar una
referencia a un objeto de su mismo tipo
17. ¿Qué es el puntero implícito this?
This se define dentro de un objeto como un puntero que este contenido, es necesario cuando es
necesario referenciar un puntero al objeto que está en la lista.

2
0
Práctica N° 2: Manejo de Excepciones
18. ¿Cómo se usa el puntero implícito this?
Se usa con el codigo class_name*this; se inicia para apuntar al objeto que se llama a la función
miembro.
19. ¿Por qué tenemos que usar el puntero implícito this?
Para definir el lugar de almacenamiento que se invocó en una función.
20. ¿Cuáles son los tipos de clases de almacenamiento?
Son los siguientes: auto, register, static, extern, mutable y tread_local
21. ¿Cuál es la forma como se representa una clase en UML?
Una clase representa un conjunto de objetos o un solo objeto que tienen una estructura. Estos se
representan por un rectángulo que incluye filas del nombre de la clase, sus operaciones y atributos.
22. ¿Cómo se representa los miembros públicos en un diagrama de clases?
Se presentan con un signo de más “+” si los miembros son públicos.

23. ¿Cómo se representa los miembros privados en un diagrama de clases?

Se presentan con un signo de menos “-” si los miembros son privados.

24. ¿Cómo se representa los miembros protegidos en un diagrama de clases?

Se presentan con un signo de numeral “#” si los miembros son protegidos.

25. ¿Cómo se representa una relación binaria en un diagrama de clases?

26. ¿Cómo se representa una relación reflexiva en un diagrama de clases?

2
1
Práctica N° 2: Manejo de Excepciones

27. ¿Cómo se representa una relación n-aria en un diagrama de clases?

28. ¿Cómo se representa una relación de agregación en un diagrama de clases?

29. ¿Cómo se representa una relación de composición en un diagrama de clases?

30. ¿Cómo se representa una relación de dependencia en un diagrama de clases?

31. ¿Cómo se representa una relación de herencia en un diagrama de clases?

2
2
Práctica N° 2: Manejo de Excepciones

8. BIBLIOGRAFÍA

8.1 Marco teórico

1. Niko Mylonakis.,” Una notación algorítmica con genericidad y herencia junto con su relación con C++
y Java” [En línea]. Disponible: https://bit.ly/3nxumdH [Accedido:29 abril 2021]
2. HM Deitel, PJ Deitel.,” Cómo programar en C/C++ y Java”., [En línea]. Disponible:
https://bit.ly/2PAU44t [Accedido:29 abril 2021]
3. E.Hernandez Orallo.,” C++ estándar” [En línea]. Disponible: https://bit.ly/3aNDBBq [Accedido:29
abril 2021]
4. FJC Sierra., “Programación orientada a objetos con C++” [En línea]. Disponible:
https://bit.ly/3gMdSwZ [Accedido:29 abril 2021]
5. Murray Hill.,” An Overview of C++ “[En línea]. Disponible: https://bit.ly/3xtKIse [Accedido:29 abril
2021]
6. MP Cline, G Lomow, M Girou.,” C++ FAQs” [En línea]. Disponible: https://bit.ly/3xzGJdD
[Accedido:29 abril 2021]
7. AG Carrillo.,” Fundamentos de programación en C++” [En línea]. Disponible: https://bit.ly/3nA2G87
[Accedido:29 abril 2021]
8. FJC Sierra.,” Programación orientada a objetos con C++” [En línea]. Disponible:
https://bit.ly/3eBWPuM [Accedido:29 abril 2021]
9. CJ De Parga.,” UML. Aplicaciones en Java y C++” [En línea]. Disponible: https://bit.ly/2QHfGN2
[Accedido:29 abril 2021]

2
3