Tema3 AI

Tema 3: Programación orientada a
objetos (POO) en C++
1 Tema 3: POO en C++

Índice
1. Técnicas de programación
2. Tipos de Datos
3. Definición de clases
4. Constructores y destructores
5. Otros elementos

Técnicas de Programación
Programar es
…
 Automatizar la resolución de problemas (reales)
mediante una máquina (ordenador).
 Resolver un problema requiere:
 Información que represente el “mundo” del problema.(Datos)
 Mecanismos para procesar/manipular la información.
(Algoritmos)
Algoritmos + Datos = Programas

Programación NO Modular
 Elemento Clave: Algoritmo (instrucciones, por delante de los datos)
Programa
 Pequeños programas con:
 Toda la secuencia de instrucciones del programa programa principal
datos
incluida en una sola función (main)
 Datos incluidos en variables con ámbito global a todo el programa
 Codificación poco eficiente (sobre todo para grandes programas):
 Necesidad de repetir las secuencias de instrucciones
Solución
Extraer las secuencias de instrucciones que se repiten
fuera del programa principal->procedimientos/funciones

Programación Modular (1)
 Soportada tanto por C como por C++.
 Elemento Clave: Algoritmo (las instrucciones, por delante de los
datos)
 Para resolver el problema con un programa …

 Descomponemos el problema en subproblemas, y repetimos el proceso
hasta codificar todo el programa en un conjunto de funciones
 Los datos se almacenan en variables y se pasan entre distintas

funciones para su procesamiento. Normalmente entre main() y el
resto de funciones
 Las funciones se comunican entre sí a través de los argumentos
de la función y el valor devuelto.

Programación Modular (2)
 Un programa es: secuencia de funciones y
procedimientos
 La función principal pasa los datos al resto de funciones que los
procesan. Programa
programa principal
datos
datos datos
func1 func2 proc
Mariano Pérez
func3

Programación Orientada a Objetos (1)
 Soportada por C++ (pero no por C)
 Elemento Clave: Objetos
 Para resolver el problema con un programa …

 Se determina que objetos (entidades que encapsulan (agrupan)
datos e instrucciones) son necesarios y cómo deberían colaborar
para resolverlo
 Los datos y las operaciones aplicables a ellos, forman

ahora una única entidad: los objetos

Programación Orientada a Objetos (2)
 Un programa es: Conjunto de objetos interactuando.
Programa
Objeto 1
Objeto 3
Objeto 4
Objeto 2

Índice
2. Tipos de Datos
5. Otros elementos
9 Tema 3: POO en C++ Asig.: Ampliación de Informática Mariano Pérez

Tipo de Datos, Clase
Tipos de Datos
 Los tipos de datos son abstracciones (elementos de
programación) que permiten declarar la naturaleza de la
información manejada en un programa.
 Especifican tanto el conjunto de valores válidos como sus

operaciones:
 Cómo son los datos y cómo se manipulan (operaciones)
 Ejemplo: int x;
 ¿Qué representa dicha sentencia?
 x puede almacenar números enteros en un determinado rango
(dominio).
 x puede intervenir en (o ser manipulada mediante) determinadas
operaciones.

Booleanos
Carácter
Predefinidos totalmente
Simples Enteros
por el lenguaje
Reales
Punteros
Tipos de datos Arrays

Definidos parcialmente
en C++ Compuestos (vectores/matrices) por el programador
Cadenas
Estructuras
Clases Definidos totalmente

(POO) por el programador

Estructuras
 Es habitual tener en un programa una estructura y
varias funciones que procesan sus datos.
 A estas funciones se les suele pasar un puntero o una
referencia a la estructura:
//Estructura que almacena los datos de una persona.

struct Persona {
string nombre, direccion;
};
//Funciones que manipulan los datos de la estructura

//Función que inicializa la estructura.
void inicializa(Persona &p, string nombre, string direccion);
//Función que imprime los datos de la estructura
void imprime(const Persona &p);

Estructuras (2)
//Funcion inicializa.
void inicializa(Persona *p,
&p, string nom, string direc)
{
p->nombre==nom;
p.nombre nom; //
//(*p).nombre
(*p).nombre==nom;
nom;
p->direccion==direc;
p.direccion direc;
}
//Funcion imprime.
void imprime(const Persona &p)
{
cout << “Nombre:” << p.nombre << endl;
cout << “Direccion:” << p.direccion << endl;
}
void main()
{
Persona x; //Variable tipo struct persona
//LLama a las funciones
inicializa(&x,“Maria”,”Calle
inicializa(x, “Maria”,”CalleMayor”);
Mayor”);
imprime(x);
}
Clases
 Los lenguajes orientados a objetos introducen el concepto de
Clase como la forma de especificar conjuntamente datos +
operaciones.
 Se puede entender como una evolución del tipo de dato

estructura donde además de datos incluye las operaciones
(funciones) para manejar dichos datos
 Antes de construir un tipo de datos mediante una clase es
necesario tener una especificación clara de las características
que debe poseer el tipo de dato:
 Dominio, conjunto de valores válidos, que información va a manipular
 Operaciones, mecanismos de manipulación de los datos
 Comportamiento esperado de las operaciones

Clases (2)
 Una clase contiene atributos (=datos) y métodos (=operaciones)
 Definición en C++ de una clase:
Nombre
class Persona{
de la clase
// Atributos (Datos)
string nombre;
string direccion;
..............
// Métodos (Operaciones)
inicializa (..);
imprime();
Imprescindible
;
}

Objetos
• Instancias de una clase: “ejemplos” reales de la clase.
• Identificados por medio de un nombre.
Persona Clase = Concepto
Objetos = Ejemplos
concretos de la clase que
Juan María Ana José responden al concepto.

Índice
2. Tipos de Datos
5. Otros elementos

Definición de Clases
Las Clases
 El concepto de clase se puede entender como una

evolución de las estructuras
 Los campos de una clase no sólo son variables como en las
estructuras, también las funciones son campos de la clase.
 Las variables y las funciones que manejan dichas

variables se “encapsulan” en un solo paquete que
conforma la clase.
 A las variables miembro de la clase se les suele denominar
también “atributos de la clase”
 A las funciones miembro: “métodos de la clase”.

Atributos (datos miembro) de una clase:
 Para declarar un atributo se procede de forma similar a
como se declara un campo de una estructura.
 Los atributos no pueden ser inicializados durante la
declaración. private, indica que son privados al
 Ejemplo: objeto, solo puede manipularlos el
objeto
class Complejo
{
private: Declaración correcta
float real;
float imaginario = 0;
};
Incorrecta. No se
puede inicializar

Métodos (funciones miembro) de una clase
 Los métodos de una clase definen las operaciones que se
pueden realizar con sus atributos.
 Para declarar un método de una clase se procede de forma
similar a la declaración de una función cualquiera.
 El cuerpo de una clase sólo contiene los prototipos de los
métodos
 El método se define aparte El operador de alcance señala la
clase a la que pertenece el
class Complejo método
{
private: void Complejo::Asignar(float x,
float real,imag; float y)
public: {
void Asignar (float x, float y); real = x; imag = y;
}; //... Más código
}
acceso a los atributos

Prototipo del método
Objetos
 Un Objeto es un ejemplar concreto de una clase.
 Las clases son el tipo de datos, mientras que los objetos son
las variables concretas de ese tipo
 Los objetos constan de una estructura interna (los atributos) y
de una interfaz que permite manipular tal estructura (los
métodos)
 Se crean del mismo modo que cualquier variable:
void main(){ Objetos de la clase

Complejo miobjeto1, miobj2; Complejo
……
}
 Cada objeto tiene sus propios atributos (son variables
independientes).
 Cada objeto tiene su propia copia de los métodos de la
clase.

class Persona { Métodos de la clase
public:
void Inicializa(string, string);
void Imprime();
private:
string nombre, direccion; Atributos de la clase
};
void Persona::Inicializa(string nom, string dir) {
nombre = nom;
direccion = dir; Utilizamos el operador de alcance
} :: junto al nombre de la clase
void Persona::Imprime() { para indicar que la función
cout << nombre << endl; miembro es de esa clase.
cout << direccion << endl;
}
void main() { Objeto de la clase
Persona p1, p2; Persona
p1.Inicializa(“Maria”,”C. Mayor”);
p1.Imprime();
}
Con el operador punto
accedemos a los miembros
22 Tema 3: POO en C++ de la clase.
Representación de Objetos (Ejemplo Persona)
Persona p1, p2;
p1 p2
nombre nombre
direccion direccion
Imprime() Imprime()
Inicializa(...) Inicializa(...)
void Persona::Inicializa(string nom,

string dir)
{
nombre = nom;
direccion = dir;
}

Persona p1, p2;
p1 p2
nombre Maria nombre
direccion C/ Mayor direccion
Imprime() Imprime()

string dir)
{
p1.Inicializa("Maria","C/ Mayor"); nombre = nom;
direccion = dir;
}

Persona p1, p2;
p1 p2
nombre Maria nombre Juan
direccion C/ Mayor direccion C/ Cuenca
Imprime() Imprime()

string dir)
{
p2.Inicializa("Juan","C/ Cuenca"); nombre = nom;
direccion = dir;
}

 Define el tipo de dato Fecha para representar un conjunto
de fechas válidas
 Una Fecha queda especificada por tres valores enteros (día, mes y
año)
 Las operaciones asociadas al nuevo tipo serán:
Ejercicio
asignarFecha(int d, int m, int a); // genera una fecha valida

incrementarFecha(); //modifica la fecha al día siguiente
visualizarFecha(); // imprime por pantalla la fecha
 Para simplificar el problema supondremos que todos los meses
tienen 31 días
 La clase se empleará en un programa cuya función principal es la
siguiente:
int main() {
Fecha f;
f.asignarFecha(31,7,2011);
f.visualizarFecha(); // 31 – 7 - 2011
f.incrementarFecha(); // se incrementa un día
f.visualizaFecha(); // 1 – 8 - 2011
}

Implementación
 La definición de la clase se suele hacer dentro de un fichero de
cabecera
 NombreClase.h
 El archivo de cabecera se incluye en todos los programas que utilice
la clase, después de los includes definidos por el compilador. Su
sintaxis es diferente:
 #include “NombreClase.h” // va entre comillas dobles en lugar de <>
 Los métodos de la clase se suelen implementar en un fichero a
parte cuyo nombre será el mismo que el nombre dado al
fichero de cabecera, pero acabado en .cpp
 NombreClase.cpp
 Cada fichero cpp debe ser compilado por separado, enlazando

todos para crear el programa ejecutable. Esto se consigue
creando un proyecto en DevC++
persona.h persona.cpp
class Persona { void Persona::Inicializa(string nom,
public: string direc) {
void Inicializa(string nom,
string direc); nombre = nom;
void Imprime(); direccion = direc;
private: }
string nombre, direccion; void Persona::Imprime() {
};
cout << nombre << endl;
cout << direccion << endl;
programa.cpp }
#include <string>
#include "persona.h"
Inclusión de los archivos
void main() { de cabecera con la
Persona p; definición de las clases
string nom_per, dir_per;
cin >> nom_per;
cin >> dir_per;
p.Inicializa(nom_per, dir_per);
p.Imprime();
}
Encapsulación de los miembros de una clase
 La encapsulación permite controlar el acceso a los

elementos de una clase (atributos o métodos) desde otras
partes del programa (ajenas a la clase) y evitar un uso
inadecuado de los mismos.
 C++ ofrece, entre otros, dos métodos de encapsulación:

public y private.
 public: los atributos y métodos incluidos en una sección pública
estarán accesibles para todo el código del programa.
 private: los atributos y métodos incluidos en una sección privada
sólo serán accesibles dentro del código de los métodos que forman
parte de la clase.
 Por omisión, los miembros de la clase son privados.
class Persona {
public:
Parte pública de la clase void Inicializa(string nom, string direc);
void Imprime();
private:
Parte privada de la clase string nombre, direccion;
};
void Persona::Inicializa(string nom, string direc) {
nombre = nom;
direccion = direc;
}
void Persona::Imprime() {
cout << nombre;
cout << direccion;
}
void main() {
Persona x, y;
x.Inicializa(“Maria”,”C. Mayor”);
Acceso Correcto
x.Imprime();
Acceso Incorrecto x.nombre = “Carmen”; //Error en compilación
}
class Hora {
public:
Todos los miembros void Poner(int nHora, int nMinutos);
de la clase son públicos void Mostrar();
int hora, minutos; //ESTO NO SE DEBE HACER NUNCA
};
void main() {
Hora h1, h2;
h1.Poner(9,30);
cin >> h2.hora;
No falla la
compilación, pero el cin >> h2.minutos;
Acceso no es h1.Mostrar();
Correcto, se rompe h2.Mostrar();
el encapsulamiento }
void Hora::Poner(int nHora, int nMinutos) {
if ( nHora >= 0 && nHora < 24)
hora = nHora;
if ( nMinutos >= 0 && nMinutos < 60)
minutos = nMinutos;
}
void Persona::Mostrar() {
cout << hora << ":" << minutos << endl;
}
Ocultación de la Información
 Normalmente se definen como privado los atributos de la clase
y como públicos los métodos que operan o acceden a los
atributos.
 De esta forma no se puede acceder directamente a los atributos, así
se evita que se usen de forma inadecuada.
 A los métodos públicos de la clase se las llama ‘interfaz’ de la
clase.
 Son el mecanismo para interactuar con el objeto
 El interfaz indica lo que se puede hacer con la clase, no necesitamos
saber como está implementada para utilizarla.
 Ventajas:
 Es más sencillo operar con los objetos, Sólo necesitamos conocer los
métodos del interfaz para operar con los objetos sin necesidad de
conocer como está implementado por dentro el objeto
 Se puede cambiar los atributos y la implementación de las
operaciones sin modificar el código que usa de los objetos
complejo.h complejo.cpp
class Complejo{ ...
public:
void Suma(Complejo c1, Complejo
c2);
void Asigna(float r, float i); Interfaz
void Muestra(); La implementación
private: podría ser desconocida
// Aquí irían los atributos
... (class string)
};
programa.cpp
#include "complejo.h"
#include <string> Inclusión de los
archivos de cabecera
void main() {
Complejo c1,c2,c3;
c1.Asigna(1.5, 6); c2.Asigna(4, 5.5); No necesitamos conocer
c3.Suma(c1,c2); la implementación
c3.Muestra();
}

Índice
2. Tipos de Datos
5. Otros elementos

Constructores y Destructores
 Un objeto NO se inicializa como las variables:
class Hora { Hora x = 10; Error
private: Hora y = {9,30};
int hora, minutos;
...
};
 ¿Qué valores tienen sus atributos después de la

declaración?
Hora x;
 ¿Cómo puedo establecer el estado inicial de los
objetos de una clase (de los atributos de los objetos)?
 Para solucionar este problema, C++ permite inicializar
el objeto de una determinada clase en el momento de
su declaración mediante un constructor

Constructor
 El constructor es un método de la clase con el mismo
nombre que la clase.
 No puede devolver ningún valor.
//Declaracion de la clase ‘Hora’, con un constructor
class Hora{
public: //Métodos públicos
Declaración Hora();
del constructor void Mostrar();
...
No devuelve
private:
int hora, minutos; ningún valor
};
Hora::Hora()
Definición del {
constructor hora = minutos = 0;
}

Llamada al Constructor
 No se llama directamente. Se llama “automáticamente”
cada vez que se crea un objeto de una clase
 Si un objeto es una variable local en una función, el constructor es
llamado cuando se invoca a dicha función.
 Si un objeto es una variable global o static, el constructor es
llamado cuando empieza el programa (antes de comenzar la ejec.
del main);
Hora h1; //Objeto global de la clase Prueba.
void func()
{
Hora h2; //Objeto local
...
}
int main()
{
Hora h3; //Objeto local a la función main
...
}
Tareas del Constructor
 Se utiliza para inicializar el objeto de forma adecuada cuando se crea.
 Para inicializar los atributos del objeto (y que no tengan un valor basura)
 Para reservar la memoria dinámica necesaria en el objeto
 Etc. complejo.cpp
void Complejo::Asignar(float x,
complejo.h float y)
class Complejo { {
private: real = x; imag = y;
float real,imag; }
public: ……
void Asignar(float x, float y); Complejo::Complejo()
void Mostrar(); {
Complejo(); real = imag = 0;
}; }
Complejo c1;
Se invoca el constructor programa.c
c1.Mostrar();
en este punto. c1.Asignar(1,1); pp
Constructor con argumentos (sobrecarga del constructor)
 La sobrecarga de funciones de C++ permite tener varios constructores, con
distintos argumentos
 Podemos tener varios constructores para inicializar de distintas formas el
objeto.
 Un constructor sin argumentos y uno o varios constructores con
argumentos.
 El constructor sin argumentos se denomina el constructor por defecto.
class Hora { Hora::Hora()

private: Constructor {
int hora,minutos; por defecto hora = minutos = 0;
public: }
Hora();
Hora::Hora(int h, int m)
Hora(int h, int m);
{
...
hora = h; minutos = m;
}; Constructor con
}
argumentos
complejo.h
class Complejo {
complejo.cpp
private:
float real,imag; Complejo::Complejo()
public: {
void Asignar(float x, float y); real = imag = 0;
void Mostrar(); }
Complejo();
Complejo(float x, float y); Complejo::Complejo(float x,
}; float y)
{
programa.c real = x; imag = y;
void main() pp }
{
Complejo c1; void Complejo::Asignar(float x,
c1.Mostrar(); float y)
c1.Asignar(1.2,1.5); {
c1.Mostrar(); real = x; imag = y;
}
Complejo c2(2.3, -3.4); ……
c2.Mostrar();
}
Constructor copia
 Constructor que tiene como argumento un objeto de la
misma clase
 Sirve para crear objetos como copia de otros objetos
 Si no se define de forma explícita el compilador crea
uno automáticamente (no visible en el código) que copia
bit a bit los valores de los atributos
 También se utiliza de forma implícita cuando pasamos
por valor un objeto a una función/método.

class Hora { Hora::Hora(const Hora &h)
private: {
int hora,minutos; Constructor hora = h.hora;
public: copia minutos = h.minutos;
Hora(); }
Hora(int h, int m); ...
Hora(const Hora &h);
... Hora func(Hora hp)
}; {
...
return hp;
También se invoca
} al constructor copia
int main()
{
Se invoca al Hora h1(10,20);
constructor copia Hora h2(h1);
Hora h3 = h2;
h3 = h1;
h3 = func(h1);
}

 Dado el siguiente código, índica cuantos constructores tiene la
clase “CuentaBanc” y marca las líneas de código donde se
invocan
class CuentaBanc { CuentaBanc::CuentaBanc () {
public: saldo =0;
CuentaBanc( ); tasa_de_interes = 0;
}
Ejercicio
CuentaBanc(int, int, double);

CuentaBanc(double, double); CuentaBanc::CuentaBanc (int euros,
CuentaBanc(const CuentaBanc &); int cents, double tasa)
double obtener_saldo( ); {
double obtener_tasa( ); saldo = euros + 0.01*cents;
void salida(); tasa_de_interes = tasa;
void igual(CuentaBanc); }
private: CuentaBanc::CuentaBanc ( double
misaldo, double interes)
double saldo;
{
double tasa_de_interes;
saldo = misaldo;
};
tasa_de_interes = interes;
int main() {
CuentaBanc cuenta1(100,2.3); }
CuentaBanc cuenta2; void CuentaBanc::Igual(CuentaBanc b)
CuentaBanc cuenta3 = cuenta1; {
cuenta2 = cuenta3; if ( saldo== b.saldo &&
cuenta1.salida(); tasa_de_interes ==
b.tasa_de_interes )
cuenta3.igual(cuenta1);
...
}
Puntero this
 Hay un puntero especial en todas las clases, es el
puntero this.
 Este puntero apunta al objeto implícito, lo que nos permite acceder
a él directamente.
 this es un puntero al objeto implícito.
 *this es el contenido del objeto implícito.

Destructor
 Es un método especial de una clase.
 El nombre del destructor será el símbolo ~ (126 ASCII o
Alt+126) seguido del nombre de la clase. Ej: ~Hora();
 No tiene argumentos ni valor de retorno.
 No se pude llamar de forma explicita. Es llamado
automáticamente cuando se destruye el objeto.
 Si el objeto es local, el destructor es invocado cuando
la función en la que ha sido creado finaliza.
 Si el objeto es global o static, el destructor es llamado
instantes antes de que termine el programa.
 La mayor importancia del destructor es la de liberar la
memoria dinámica reservada en la creación del objeto.

class Vector { Vector::~Vector() { //Destruc.
public: delete []datos;
Vector(); //Constructor }
Vector(int); //Constructor
~ Vector(); //Destructor void Vector::setValor(int ind, float
void setValor(int, float); v) {
float getValor(int); if ( ind >= 0 && ind < tam )
private: datos[ind] = v;
float *datos; }
int tamanyo; float Vector::getValor(int ind) {
}; if ( ind >= 0 && ind < tam )
Vector::Vector() { return datos[ind];
tamanyo = 0; else
datos = NULL; return 0;
} }
Vector::Vector(int tam) {
tamanyo = tam; void main()
datos = new float[tam]; {
for ( int i=0; i<tam; i++ ) Vector v(5);
datos[i] = 0; v.setValor(0, 2.3);
} cout << v.getValor(0) << endl;
}
 Crear un clase matriz, que permita la creación de una
matriz de tamaño introducido por el usuario, la clase
deberá permitir asignar valores a sus componentes,
leerlos, mostrar la matriz. También deberá sumar dos
Ejercicio
matrices. Habrá que construir un constructor por

defecto, uno con parámetros que inicialice la matriz y
un destructor que libere la memoria dinámica.

Índice
2. Tipos de Datos
5. Otros elementos

Otros elementos
Reserva dinámica de objetos
 La reserva de memoria dinámica para un objeto de una

clase es similar a la forma en la que reservamos memoria
dinámica para una estructura,
 Pasos:
 Se declara un puntero de tipo base la clase del objeto que se
desea crear (por ejemplo Complejo *p;)
 Se crea el objeto con el operador new
 Se accede a los atributos y métodos públicos del objeto dinámico a
través del puntero, usando el operador ->
 Cuando ya no es necesario el objeto en el programa, se destruye
con el operador delete
Otros elementos
Reserva dinámica de objetos (2)
class Complejo {
private: void main()
float real,imag; {
public: Complejo *pc;
Complejo(){real= 0; imag= 0;} pc = new Complejo;
Complejo(float x, float y); pc->Asignar(2,3);
~Complejo(); pc->Mostrar();
void Asignar(float x, float y); delete pc;
void Mostrar(); }
};
real 2
pc
imag 3
Asignar(...)
Mostrar()
Complejo()
Complejo(...)

Otros elementos
Reserva dinámica de objetos (3)
 Partiendo de la anterior definición de la clase Complejo
¿Qué Mostraría el siguiente código? Complejo *pc2;
pc2 = new Complejo;
pc2->Mostrar();
 Reserva de memoria para un objeto, e inicialización con argumentos:
Complejo *pc; //Puntero a objeto de la clase Complejo

//Reserva memoria y llama al constructor con argumentos
pc = new Complejo(5.3, 6.4);
 Array de objetos de una clase:
Complejo *parray;
parray = new Complejo[20]; //Array de 20 objetos
delete [] parray;

Otros elementos
Métodos En Línea
 Los métodos en línea, al igual que las funciones en línea, son
métodos especiales; el compilador sustituye la llamada a la
función por su código.
 Hacen más eficiente el código, ahorrando el tiempo de

ejecución invertido en la llamada al método.
 ¿Cuándo utilizarlos?:
 En general, no deberían utilizarse.
 Se aplicaría cuando el programa ya ha sido completamente
desarrollado y depurado, y se comprueba que ciertos métodos
hacen más lenta la ejecución del programa.
 En cualquier caso, sólo son aplicables a métodos con muy pocos
pasos
 Por ejemplo: que se limitan a modificar un atributo (set), a mostrar un
atributo (get), etc.
Otros elementos
Definición de Métodos en Línea (2 métodos)
 Añadiendo la palabra reservada inline en la cabecera de la definición
class Complejo { Cuando se invoque al
public: método el compilador
void Mostrar();
......... sustituirá el contenido del
}; método en lugar de la
inline void Complejo::Mostrar() { llamada
cout << real << "+i" << imag << endl;
}
 Dentro de la definición de la clase

class Complejo {
public:
void Mostrar() { El código del método
cout << real << "+i" << imag; se añade directamente
} en la definición de la
..... clase
};
Otros elementos
Composición de Objetos
 Uno o varios atributos de la clase son a su vez objetos de otra clase.
persona.h fecha.h
class Persona { class Fecha{
public: public:
void Inicializa(string, string, Fecha();
Fecha); Fecha(int, int, int);
void Imprime(); int obtenerAnyo();
int obtenerAnyoNac(); int obtenerMes();
Persona(); int obtenerDia();
Persona(string, string, Fecha); void visualizarFecha();
private: void asignarFecha(int, int, int);
string nombre, direccion; void incrementarFecha();
Fecha nacimiento; private:
}; int anyo, mes, dia;
};
¿Cómo implementar obtenerAnyoNac()?

Otros elementos
 Composición: Uno o varios atributos de la clase son a
su vez objetos de otra clase.
 Ej: la siguiente clase Persona almacena información del
‘cumpleaños’, utilizando la clase “Fecha”, que contiene tres
enteros para el día, mes y año, y funciones que los devuelven.
class Persona{
public:
int obtenerAnyoNac();
private:
string nombre, direccion;
Fecha nacimiento;
}
 Las funciones de la clase Persona, podrán utilizar las

funciones del interfaz de la clase Fecha.
int Persona::obtenerAnyoNac () Llama a la función
{ obteneranyo de la
return( nacimiento.obteneranyo()); clase Fecha.
}
55 Tema 4: Clases
 Crear un programa que permita sumar dos vectores de
tamaño introducido por el usuario de objetos complejos
usando reserva dinámica de memoria y clases. Para
ello crearemos la clase complejo, que deberá tener una
Ejercicio
función inicializa, visualiza, suma y resta dos

complejos, y la clase vector complejo (haz método leer,
mostrar y sumar dos vectores, con los constructores y
destructores)
tarea aulavirtual

Otros elementos
Definición de Funciones Friend (amigas)
 Los miembros de una clase declarados como privados solamente
pueden ser accedidos mediante las funciones miembro de la clase,
garantizando así la integridad de los datos.
 A veces puede interesar que los miembros de otra clase o funciones
externas puedan acceder a alguno de estos miembros privados.
 Ej:
class CA { //Clase CA: almacena un entero y devuelve su valor

public:
CA(int v) {valor = v;} //Constructor
int getval () {return (valor);}
private:
int valor;
};
void decrementa( CA &dato){ Intentan modificar el
dato.valor--; atributo privado
} “valor”.
class CB{
Esto NO compila (no
public:
void cambia(CA &dato){dato.valor++;} se acceder a un
} miembro privado de la
clase CA).
57 Tema 4: Clases
Otros elementos
Definición de Funciones Friend (amigas)
 Podemos permitir que la función decrementa() y los métodos de
CB accedan a los datos de la clase CA, declarándolas como
amigas: usando la palabra reservada friend.
class CA
{
public:
friend class CB;
friend void decrementa (CA &dato);
.............
};
 Las funciones y clases friend dan flexibilidad al C++ ya que
permite a funciones que no pertenecen a la clase acceder a sus
atributos y métodos privados por medio del operador (.) y flecha
(->).
 Al declarar la función decrementa() como friend, permitimos que
dentro de la función se pueda acceder a los atributos y métodos
privados de la clase CA.
 Al declarar la clase CB como amiga de la clase CA, todos los
métodos de la clase CB tendrán acceso a los atributos y métodos
privados de la clase CA.
58 Tema 4: Clases
Otros elementos
Funciones Friend (amigas)
 La ‘amistad’ no es mutua: CB es friend de CA, pero no al

revés (CA no podrá acceder a los miembros privados de la
clase CB).
 Este mecanismo es contrario a la regla de ocultación de

información, por ello su uso debe ser restringido.
 Solo lo utilizaremos en la sobrecarga de algunos operadores.
59 Tema 4: Clases

Tema3 AI

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

Tema3 AI

Cargado por

Copyright:

Formatos disponibles

Tema 3: Programación orientada a

objetos (POO) en C++

1 Tema 3: POO en C++

2 Tema 3: POO en C++

Algoritmos + Datos = Programas

3 Tema 3: POO en C++

4 Tema 3: POO en C++

 Para resolver el problema con un programa …

 Los datos se almacenan en variables y se pasan entre distintas

5 Tema 3: POO en C++

6 Tema 3: POO en C++

 Para resolver el problema con un programa …

 Los datos y las operaciones aplicables a ellos, forman

7 Tema 3: POO en C++

8 Tema 3: POO en C++

9 Tema 3: POO en C++ Asig.: Ampliación de Informática Mariano Pérez

 Especifican tanto el conjunto de valores válidos como sus

10 Tema 3: POO en C++

Tipos de datos Arrays

Clases Definidos totalmente

11 Tema 3: POO en C++

//Estructura que almacena los datos de una persona.

//Funciones que manipulan los datos de la estructura

12 Tema 3: POO en C++

 Se puede entender como una evolución del tipo de dato

14 Tema 3: POO en C++

15 Tema 3: POO en C++

Persona Clase = Concepto

16 Tema 3: POO en C++

17 Tema 3: POO en C++ Asig.: Ampliación de Informática Mariano Pérez

 El concepto de clase se puede entender como una

 Las variables y las funciones que manejan dichas

18 Tema 3: POO en C++

19 Tema 3: POO en C++

acceso a los atributos

void main(){ Objetos de la clase

21 Tema 3: POO en C++

void Persona::Inicializa(string nom,

23 Tema 3: POO en C++

void Persona::Inicializa(string nom,

24 Tema 3: POO en C++

void Persona::Inicializa(string nom,

25 Tema 3: POO en C++

asignarFecha(int d, int m, int a); // genera una fecha valida

26 Tema 3: POO en C++

 Cada fichero cpp debe ser compilado por separado, enlazando

 La encapsulación permite controlar el acceso a los

 C++ ofrece, entre otros, dos métodos de encapsulación:

33 Tema 3: POO en C++

34 Tema 3: POO en C++

 ¿Qué valores tienen sus atributos después de la

35 Tema 3: POO en C++

36 Tema 3: POO en C++

class Hora { Hora::Hora()

41 Tema 3: POO en C++

42 Tema 3: POO en C++

CuentaBanc(int, int, double);

44 Tema 3: POO en C++ Asig.: Ampliación de Informática Mariano Pérez

45 Tema 3: POO en C++

matrices. Habrá que construir un constructor por

47 Tema 3: POO en C++

48 Tema 3: POO en C++ Asig.: Ampliación de Informática Mariano Pérez

 La reserva de memoria dinámica para un objeto de una