PDF de programación - SEMINARIO DE C++ - Sesión 2

Algoritmos y Estructuras de Datos

Ingeniería en Informática, Curso 2º

SEMINARIO DE C++

Sesión 2



Contenidos:

1. Definición de clases
2. Implementación de los métodos
3. Constructores y destructores
4. Objetos dinámicos
5. Algunas notas
Ejercicios



Algoritmos y Estructuras de Datos
Seminario de C++ – Sesión 2



2/9



1. Definición de clases

• La programación orientada a objetos se basa en el uso de clases y objetos.

o Modelo imperativo: un programa es una sucesión de instrucciones que
o Modelo orientado a objetos: un programa está formado por un conjunto

se ejecutan secuencial o iterativamente.

de objetos que se comunican entre sí.

• Naturaleza dual de las clases:

o Una clase es un tipo abstracto de datos (mecanismo para crear nuevos
tipos definidos por el usuario). Mecanismo similar a las estructuras, pero
incluyendo tanto los datos y como las funciones del tipo.
o Una clase es un módulo que proporciona encapsulación (agrupa
funciones y datos) y ocultamiento de la implementación (parte private
y parte public).



o Miembros de una clase: atributos y operaciones de la clase (datos y
funciones miembro). Ej.: nombre, dni y edad son datos miembros de la
clase persona.
o Métodos de una clase: funciones definidas dentro de esa clase. Ej.: leer()
o Mensaje: invocación de un método sobre un objeto. Ej.: p1.leer(f1); y
o Objeto receptor: el objeto receptor de un mensaje es el objeto sobre el que

p1.escribir(); son mensajes aplicados sobre el objeto p1.

y escribir() son métodos de la clase persona.

se aplica. Ej.: en p1.leer(f1), el objeto receptor es p1.



// persona es una clase



• Un objeto es una variable cuyo tipo es una clase.
class persona
{
char nombre[80];
long dni, telefono;
int edad;

void leer (FILE *f);
void escribir (void);
};

persona p1;
p1.leer(f1);
p1.edad++;
p1.escribir();


• Nomenclatura:



// p1 es un objeto de clase persona

Algoritmos y Estructuras de Datos
Seminario de C++ – Sesión 2



3/9



• Declaración de una clase. Sintaxis.
class nombre {
... // Miembros de la clase
};

• Miembros públicos y privados.

class nombre {
private:
... // Miembros privados
public:
... // Miembros públicos
};


o Miembros públicos. public: Son accesibles para el usuario de la clase.
o Miembros privados. private: No son visibles para el usuario de la clase.

o Pueden aparecer varias veces (y en distinto orden) las cláusulas public: y
o Por defecto, si no se indica nada, los miembros son private.

private:

• Declaración de los miembros de una clase: Igual que la definición de variables

y funciones.
o No se permite inicialización de los datos miembros.
o En las funciones miembro, el objeto receptor es un parámetro implícito, no

hace falta indicarlo.

• Ejemplo.
class conjuntoInt {
private:
int tamano;
int datos[MAXIMO];
public:
void vaciar ();
void insertar (int n);
void suprimir (int n);
bool miembro (int n);
};

class vacia {};

class listaFloat {
private:
listaFloat * siguiente;
listaFloat * anterior;
public:
float actual;
int longitud ();
void insertar (float valor);
listaFloat * avanzar ();
listaFloat * retroceder ();
};



Algoritmos y Estructuras de Datos
Seminario de C++ – Sesión 2



4/9

2. Implementación de los métodos

Igual que la implementación de una función.


•

• Normalmente, la implementación de los métodos va aparte (fuera) de la
definición de la clase. Se utiliza el operador de visibilidad ‘::’ para el nombre
del método.


void conjuntoInt::vaciar ()
{
...
}

void conjuntoInt::insertar (int n)
{
...
}

• Dentro de un método todos los miembros de esa clase (tanto públicos como

privados) son accesibles como si fueran variables (o funciones) locales.


void conjuntoInt::insertar (int n)
{
if (tamano<MAXIMO)
datos[tamano++]= n;
else
cerr << ″ERROR: el conjunto está lleno.″;
}

• Métodos in-line.





o También se puede implementar el método dentro de la definición de la clase.
o Los métodos de este tipo se llaman in-line: el compilador, al encontrar un
o No es muy aconsejable, a menos que el método sea trivial.

mensaje, sustituye la llamada directamente por el código del método.

#include <iostream>
using namespace std;

class contadorModulo10 {
private:
int estado;
public:
void iniciar() {estado= 0;}
void avanzar(int n= 1) {estado= (estado+n)%10;}
int valor() {return estado;}
};

main ()
{
contadorModulo10 cnt;
cnt.iniciar(); // ¿Qué ocurre si quitamos esto?
cnt.avanzar(12);
cnt.avanzar(); // ¿Cuánto avanza aquí?
cnt.avanzar();
cout << cnt.valor(); // ¿Qué debería imprimir?
}



Algoritmos y Estructuras de Datos
Seminario de C++ – Sesión 2

• Ejemplo. Clase conjunto de enteros con tamaño máximo limitado.



5/9

#include <iostream>
#define MAXIMO 100
using namespace std;

///////////// Declaración de la clase conjuntoInt /////////////
class conjuntoInt {
private:
int tamano;
int datos[MAXIMO];
public:
void vaciar ();
void insertar (int n);
bool miembro (int n);
};

///////////// Implementación de los métodos /////////////
void conjuntoInt::vaciar ()
{
tamano= 0;
}

void conjuntoInt::insertar (int n)
{
if (tamano<MAXIMO)
datos[tamano++]= n; // Ojo, no se comprueba si ya está el n
else
cerr << "ERROR: el conjunto está lleno.";
}

bool conjuntoInt::miembro (int n)
{
for (int i= 0; i<tamano; i++)
if (datos[i]==n)
return true;
return false;
}

///////////// Programa principal /////////////
int main (void)
{
conjuntoInt cjt;
cjt.vaciar(); // ¿Qué pasa si lo quitamos?
char comando;
cout << ">> ";
while ((cin>>comando) && (comando!='q')) {
int valor;
if (comando=='i') {
cin >> valor;
cjt.insertar(valor);
cout<<"Insertado el "<<valor;
}
else if (comando=='m') {
cin >> valor;
cout<<"¿Miembro "<<valor<<"? "<<(cjt.miembro(valor)?"SI":"NO");
}
else
cout << "Comando " << comando << " no válido. ";
cout << "\n>> ";
}
return 0;
}

Algoritmos y Estructuras de Datos
Seminario de C++ – Sesión 2



6/9

3. Constructores y destructores



• Constructor: es una operación de inicialización de un objeto.

• Por defecto, si no se definen constructores, los datos miembros de un objeto no


• El constructor de una clase es un método de esa clase, con el mismo nombre

se inicializan.

que la clase.


class conjuntoInt {
...
public:
conjuntoInt () {tamano= 0;} // Constructor del tipo
...
};


o El constructor no devuelve ningún valor.
o Se puede aplicar sobrecarga: pueden haber distintos constructores, siempre

que los parámetros de entrada sean distintos.


class conjuntoInt {
...
public:
conjuntoInt () {tamano= 0;} // Constructor de conjunto vacio
conjuntoInt (int e1) // Constructor de cjt. con 1 elem.
{datos[0]= e1; tamano= 1;}
conjuntoInt (int e1, int e2) // Constructor de cjt. con 2 elem.
{datos[0]= e1; datos[1]= e2; tamano= 2;}
...
};


• Constructor por defecto: si existe algún constructor sin parámetros (o con

todos los parámetros por defecto) se toma como constructor por defecto.


• Uso de constructores.


conjuntoInt cjt; // Se inicializa con el constructor por defecto
conjuntoInt cjt(9); // Constructor que incluye 1 elemento
conjuntoInt cjt(23,12); // Constructor que incluye 2 elementos
...

• Destructor: operación de eliminación de un objeto.


o El nombre del destructor es 'ÑombreClase'.
o No devuelve ningún valor, ni recibe ningún parámetro.
o Es necesario definir un destructor si el objeto ha reservado memoria dinámica

o ha abierto algún fichero.



class conjuntoInt {
...
public:
~conjuntoInt () {cout<<"Nada";} // Destructor, irrelevante aquí
...
};








Algoritmos y Estructuras de Datos
Seminario de C++ – Sesión 2



7/9

4. Objetos en memoria dinámica

• Igual que con cualquier otro tipo de datos. Se pueden crear nuevos objetos en

memoria dinámica con new, new[] y eliminarlos con delete y delete[].



→ Crear un nuevo objeto usando un constructor específico.

→ Crear un nuevo objeto usando el constructor por defecto.

nombreClase *obj1= new nombreClase;

nombreClase *obj2= new nombreClase(p1, p2, ...);

nombreClase *ad= new nombreClase[tamano];

delete obj1; → Borra el objeto dinámico, usando el destructor.
delete[] ad; → Borra un array dinámico de objetos, usando el destructor.


• Ejemplo. En el ejemplo de la clase conjuntoInt incluir el siguiente código en

→ Crear un array dinámico de objetos con el constructor por defecto.

la función main. Recordar el operador flecha '->': a->b equivale a (*a).b

conjuntoInt *c1= new conjuntoInt;
c1->insertar(19);
c1->insertar(81);
cout << c1->miembro(19);
delete c1;









• Ejemplo. Cambiar la definición de la clase conjuntoInt para que se pueda

especificar (y pueda variar) el tamaño máximo del conjunto.


class conjuntoInt {
private:
int tamano;
int MAXIMO; //Tamaño máximo variable. Quitar el #define MAXIMO 100
int *datos;
public:
conjuntoInt (int max= 20); //Constructor, por defecto tamaño 20
~conjuntoInt (); //Destructor, liberar memoria
... //Est