Practica #05 - 2020 PDF

UCSM Esc. Prof.
de Ingeniería de Sistemas INFORME DE PRÁCTICAS

Mayo - 2020 LENGUAJES DE
PROGRAMACIÓN II
Práctica N° 05
Elaborado por:
© IEEE 2013 The Institute of Electrical and Electronics Engineers, Inc.

Práctica N° 5: Vectores de Objetos, Funciones y Clases Amigas, Miembros Estáticos, Sobrecarga de Operadores en C++
ii
GRUPO N° 1
PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN II
Presentado por:
iii
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
Vectores de Objetos, Funciones y Clases Amigas, Miembros Estáticos, Sobrecarga de

Operadores
iv
ÍNDICE
1. RESÚMEN 1
2. INTRODUCCIÓN ...................................................................................................... 1
3. MARCO TEÓRICO .................................................................................................... 1
3.1 Arreglos de Objetos .......................................................................................... 1
3.2 Funciones amigas............................................................................................. 2
3.3 Clases amigas .................................................................................................. 2
3.4 Miembros static................................................................................................. 3
3.5 Sobrecarga de operadores ............................................................................... 3
4. EXPERIENCIAS DE PRÁCTICA ............................................................................... 3
4.1 Hacer arreglos de objetos en su proyecto elegido. ........................................... 1
4.2 Agregar funciones amigas, una clase(s) amiga(s) y clase(s) parcialmente
amiga(s). ................................................................................................................... 1
4.3 Agregar métodos y atributos estáticos. ............................................................. 1
4.4 Diseñar y agregar operadores sobrecargados a su proyecto. ........................... 1
5. CONCLUSIONES DE LA PRÁCTICA: ....................................................................... 2
6. CUESTIONARIO ....................................................................................................... 2
7. BIBLIOGRAFÍA ......................................................................................................... 3
v
ÍNDICE DE TABLAS Y FIGURAS
Figura N° 1: Diagrama de Clases........................................................................................ 1

Figura N° 2: código de función......................................... ¡Error! Marcador no definido.
vi
1. RESÚMEN
Los arreglos de objetos se crean de la misma forma como se crean los arreglos de tipos de datos
primitivos, sin embargo la declaración implica que esto únicamente es posible si existe un
constructor implícito, ya que no es posible en la declaración dar valores de argumentos al proceso
de inicialización de objetos, una forma de dar valores de inicialización a los objetos que forman el
arreglo es mediante una lista de inicialización, el manejo de dicha lista se puede manejar para
arreglos unidimensionales y multidimensionales, para manipular arreglos bidimensionales es mejor
utilizar arreglos de punteros y punteros dobles a los objetos.
En lenguaje C++ las funciones miembros de una clase poseen las propiedades de poder acceder a la
parte privada de la declaración de la clase, pertenecer al ámbito de la clase y de tener que ser
invocadas mediante un objeto, las funciones amigas poseen la primera propiedad y nos sirven para
poder permitir una funcionalidad externa que pueden manipular los recursos privados de la clase.
También podemos colocar como amigas de una clase a otra clase, en este contexto la clase a la que
se le permite el acceso se le denomina clase invitada y a la clase que lo permite se le llama clase
anfitriona, si la intención es proveer únicamente acceso a un método especifico de una clase solo
tenemos que hacer amigo a dicho método.
Para las ocasiones en que se necesita almacenar información asociada a la clase o a todos los objetos
de dicha clase se puede hacer uso de un atributo static, los miembros estáticos están asociados a la
clase, lo que significa que cuando se instancie un objeto no se sacará una copia del atributo static
para el objeto, este tipo de recurso nos permite definir tanto variables, constantes y métodos, al
tratarse de variables estos pueden existir antes que cualquier instancia de la clase.
La sobrecarga de operadores en Lenguaje C++ se utiliza para que podamos hacer uso de los
operadores sobrecargados en una clase para operar sobre los objetos instanciados de dicha clase. Si
la sobrecarga de operadores no se hace, al realizar una operación que involucre objetos de la clase
el compilador no sabrá como operar dichos objetos y mostrará un error de compilación; la
sobrecarga se hace de forma diferenciada para operadores unarios y binarios, muy aparate existen
dos formas de hacerlo, mediante funciones amigas o cómo métodos de clase o funciones miembro,
para el primer caso los operadores unarios que se sobrecargan con funciones amigas deben de recibir
una referencia al objeto que actúa como operando, si se tratase de un método esto no es necesario
por ser invocado por un objeto; si hablamos de operadores binarios en el caso de la función amiga
se debe devolver una referencia a un objeto y recibir dos referencias a los objetos operandos, con
un método en cambio solo necesito recibir una referencia a un objeto y devolver una referencia a un
tercer objeto para colocar el resultado.
2. INTRODUCCIÓN
Una de las principales ventajas de la Programación Orientada a Objetos (POO) es tratar a la
programación como un reflejo de la realidad, la organización de los objetos reconocidos de esta
realidad es importante para poder manipularlos de forma más eficiente. Una de las formas más
simples de organizarlos es mediante arreglos de diferente naturaleza.
Al crear un objeto primero definimos un tipo de dato, este se equipara con la clase y luego
declaramos una variable de este tipo de dato, esto se equipara con el objeto, ahora bien, para crear
un arreglo de cualquier tipo primero especificamos un tipo de dato, seguidamente declaramos el
nombre del arreglo seguido por las dimensiones del arreglo y la cantidad de espacios que serán
reservados en memoria; de la misma forma se crea un arreglo de objeto, primero se especifica el
tipo de clase, luego el nombre del arreglo de objetos y finalmente las dimensiones, para crear el
objeto se debe inicializar los objetos, lo cual se hace con la llamada implícita del constructor de
clase.
Para inicializar objetos dependemos de un constructor de clase que suministre la información
suficiente para su construcción, sin embargo, esto nos trae cierto número de limitantes para la
inicialización adecuada en arreglos de objetos ya que se creará un objeto para cada posición del
arreglo, por lo que es necesario que el objeto se inicialice sin un constructor explícito.
No hay forma de poder declarar parámetros explícitos en la declaración de un arreglo de objetos, de
1
esta forma no es posible el envío de parámetros a un constructor que lo requiera, es posible declarar
una lista de inicialización de arreglos, pero más allá de esto nada más se puede hacer para construir
los objetos existentes en el arreglo.
Una de las principales propiedades de la Programación Orientada a Objetos (POO) es el
encapsulamiento, dicha propiedad impide que se haga uso directo de miembros de clase privados o
protegidos, sin embargo hay situaciones especiales en las que es requerido hacer que alguna función
o clase tenga acceso a dichos elementos a pesar de las restricciones que impone el encapsulamiento,
en casos así es posible disponer de un recurso que nos permite que tanto funciones ajenas a la clases
como también clases puedan tener acceso directo e irrestricto a los miembros privados y protegidos.
Una función miembro o método tiene derecho a acceder a miembros privados de la clase, se
encuentra dentro del ámbito de acceso de la clase y finalmente puede ser invocada por un objeto de
dicha clase. Las funciones amigas solo poseen el primer privilegio.
Cuando una función es declarada como amiga a la clase, esta es declarada dentro de la clase como
tal, de esta forma dicha función puede acceder a todos los recursos de la clase que de otro modo
estarían restringidos por ser privados o protegidos, este artificio se lleva adelante debido a que para
poder acceder a los atributos públicos es necesario llamar a funciones públicas dentro de la misma
clase, pero este tipo de proceso consume muchos recursos de programación para situaciones
específicas donde usar métodos miembro que entreguen los valores resultan demasiado costosos.
La otra forma es cuando hacemos que una clase sea amiga de otra, en estas situaciones todos los
miembros de la clase anfitriona pueden ser accedidos por los miembros de la clase amiga, sin
embargo, la clase anfitriona no puede tener acceso a los miembros de la clase invitada, aunque es
posible hacer que las dos clases anfitriona e invitada sean mutuamente amigas permitiendo el acceso
entre ambas.
Una clase en C++ tiene dos tipos de miembros, los atributos que viene a ser variables o entidades
que almacenan valores para los objetos y los métodos que son las funciones que definen la
operatividad de los objetos dentro de un programa. Hemos estado acostumbrados a usar los
miembros de clase desde la perspectiva que cada objeto instanciado obtiene una copia particular de
los atributos y hace uso de los métodos de la clase por igual con todos los demás objetos.
Existe la posibilidad de tener variables o atributos de clase, es decir, tanto atributos y métodos que
le pertenecen a la clase y de los cuales los objetos no reciben copias si no que los usan de forma
compartida, para ello existen los atributos estáticos, cuando un atributo es manipulado como estático
tiene un solo espacio de almacenamiento para la clase y con ello los objetos al manipularla
comparten dicho atributo y su valor. De la misma forma se pueden implementar métodos estáticos
que por definición tendrían las mismas características de los atributos estáticos sin embargo si
analizamos detenidamente el asunto caemos en que los métodos están alojados en la clase y cada
objeto accede a ellos mediante punteros a función, bajo este criterio los métodos estáticos no
tendrían mayor utilidad, sin embargo, los métodos estáticos de una clase no tienen acceso a los
recursos no estáticos de la clase.
Cualquier tipo de dato básico o primitivo está definido en lenguaje C++ en términos de los valores
que son susceptibles de ser almacenados como datos en variables de su tipo y en términos de las
operaciones que son susceptibles de operar variables de dicho tipo, al declarar una clase estamos
declarando un nuevo tipo de dato, por lo tanto, debemos de especificar el formato de
almacenamiento de datos y las operaciones que afecten a los objetos de dicha clase. Una de las
ventajas de la Programación Orientada a Objetos (POO) es tratar de permitir la codificación de la
forma más natural posible y que refleje de la forma más fidedigna a la realidad, una de las formas
de hacer esto es haciendo que las operaciones sean muy naturales entre objetos, lo único que resulta
inconveniente es que las operaciones aritméticas como las de otro tipo, no están diseñadas para
operar objetos y resulta por decirlo menos un tanto complicado hacer que los operadores realicen
acciones sobre los objetos que las usan como operandos.
Sin embargo, la POO puede hacer que se definan operaciones dentro de una clase que especifiquen
como es que un operador debe afectar a un objeto cuando este actúa como operando sobre éste. Esta
definición de operaciones se hace al interior de la clase a la cual pertenecerán los objetos, las
operaciones son generalmente manejadas según el tipo de operador ya sea este unario, binario o de
otro tipo, no todos los operadores son sobrecargables en lenguaje C++, se debe tener en cuenta no
solo debemos saber cuál es la naturaleza del operador, sino también el tipo de operaciones que son
posibles de implantar. Finalmente, el efecto directo y natural de hacer la sobrecarga se reflejará
directamente en la forma de uso del operador, ya que al expresar operaciones con operadores
2
sobrecargados no se hace referencia explícita a la función miembro o amiga que implanta la

operación si no al operador de forma directa y para resolver la operación se llamará a la función
miembro o amiga que la implementa para poder operar. [ 1 ][ 2 ]
3
3. MARCO TEÓRICO
3.1 Arreglos de Objetos
¿QUÉ ES? ¿CÓMO SE DECLARA? ¿CÓMO LO USO? ¿CUÁNDO LO USO?
Los objetos son variables y La sintaxis para declarar un arreglo # include <iostream> La función básica de un arreglo
using namespace std;
tienen las mismas de objetos es la siguiente: class Ejemplo es almacenar en una variable más
capacidades y atributos que { de un valor de un mismo tipo de
cualquier otro tipo de <nombre de clase> <nombre del int a; dato, por ejemplo la siguiente
arreglo> [<numero de public:
variables. Por lo tanto, se elementos>]; void set_a(int n){ a=n;} declaración int numero [5];
pueden tener objetos en un int get_a(){ return a;} permite almacenar en la variable
};
array. La sintaxis para <nombre_clase>
arreglo>
<nombre
[<numero
del
de main()
número, 5 valores enteros.
declarar un array de objetos elementos>] = {elementos}; {
es exactamente la utilizada Ejemplo ob[4];
int i;
para declarar un array de for(i=0;i<4;i++) ob[i].set_a(i);
cualquier tipo de variable. for(i=0;i<4;i++)
Aún más, el acceso al array cout<<ob[i].get_a()<<" ";
cout<<"\n";
de objetos es igual al de los return 0;
otros tipos de variables. }
Figura N° 1: Diagrama de Clases
3.1.1 Unidimensionales
1
3.1.2 Multidimensionales
3.2 Funciones amigas

3.3 Clases amigas

2
3.4 Miembros static

3.5 Sobrecarga de operadores

3
4. MODELAMIENTO
4.1 Diagrama de clases
4.2 Diagram de secuencia
5. EXPERIENCIAS DE PRÁCTICA
5.1 Hacer arreglos de objetos en su proyecto elegido.
Colocar código documentado
5.2 Agregar funciones amigas, una clase(s) amiga(s) y clase(s) parcialmente

amiga(s).
UnaClase::~UnaClase()
{
cout << "Destructor de Clase" << endl;
//delete ptrAtributo;
}
5.3 Agregar métodos y atributos estáticos.

5.4 Diseñar y agregar operadores sobrecargados a su proyecto.

1
6. CONCLUSIONES DE LA PRÁCTICA:
a) La encapsulación de datos se refiere al control de acceso, y al uso de private, protected y
public
b) Los diagramas UML nos ayudan a saber qué tipo de acceso tiene un miembro de clase y
saber qué tipo de variable guarda, atributo, o retorna (o recibe) método.
7. CUESTIONARIO
a) ¿Qué es una función amiga?
b) ¿Cómo se declara una función amiga?
c) ¿Una función amiga debe invocarse mediante un objeto?
d) ¿Cómo se hace uso de una función amiga?
e) ¿Qué es una clase amiga?
f) ¿Cómo se declara una clase amiga?
g) ¿Cómo se hace uso de una clase amiga?
h) ¿Cómo se declara amiga parcialmente a una clase?
i) ¿La declaración friend introduce el nombre dentro del ámbito de declaración?
j) ¿Qué es un atributo estático?
k) ¿Qué es un método estático?
l) ¿Qué significa atributo de clase?
m) ¿Qué significa método de clase?
n) ¿Qué propiedades tienen los atributos estáticos?
o) ¿Para qué se utilizan los atributos estáticos?
p) ¿Qué propiedades tienen los métodos estáticos?
q) ¿Cómo se declaran punteros y referencias estáticas?
r) ¿Para qué se utilizan los punteros y referencias estáticos?
s) ¿Por qué debemos sobrecargar operadores en las clases?
t) ¿Cuáles son los operadores que se pueden sobrecargar en Lenguaje C++?
u) ¿Cuáles son los operadores que no se pueden sobrecargar en Lenguaje C++?
v) ¿Cómo se sobrecargan los operadores en una clase?
w) ¿Por qué se diferencia entre la sobrecarga de operadores unarios y binarios?
x) ¿Cómo se sobrecargan los operadores unarios mediante un método?
y) ¿Cómo se sobrecargan los operadores unarios mediante una función amiga?
z) ¿Cómo se sobrecargan los operadores binarios mediante un método?
aa) ¿Cómo se sobrecargan los operadores binarios mediante una función amiga?
bb) ¿Cómo se representa una relación de herencia en un diagrama de clases?
2
8. BIBLIOGRAFÍA
1. Deitel, Paul J., Deitel, Harvey M., "Cómo Programar en C++", 6ta Edición, Ed. Pearson Educación, México
2009.
2. Stroustrup, Bjarne, "El Lenguaje de Programación C++", 3ra Edición, Adisson Pearson Educación S.A.,
Madrid 2002.
3. Eckel, Bruce, "Thinking in C++", 2da Edición, Prentice Hall, 2000.

Practica #05 - 2020 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Practica #05 - 2020 PDF

Cargado por

Copyright:

Formatos disponibles

UCSM Esc. Prof.

de Ingeniería de Sistemas INFORME DE PRÁCTICAS

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

PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN II

Vectores de Objetos, Funciones y Clases Amigas, Miembros Estáticos, Sobrecarga de

ÍNDICE DE TABLAS Y FIGURAS

Figura N° 1: Diagrama de Clases........................................................................................ 1

sobrecargados no se hace referencia explícita a la función miembro o amiga que implanta la

Figura N° 1: Diagrama de Clases

3.2 Funciones amigas

3.3 Clases amigas

3.4 Miembros static

3.5 Sobrecarga de operadores

4.2 Diagram de secuencia

5.2 Agregar funciones amigas, una clase(s) amiga(s) y clase(s) parcialmente

5.3 Agregar métodos y atributos estáticos.

5.4 Diseñar y agregar operadores sobrecargados a su proyecto.

También podría gustarte