Sunteți pe pagina 1din 9
UNIDAD 4 CLASES Y OBJETOS 1. DEFINICIÓN DE UNA CLASE 2. DECLARACIÓN DE CLASES 3.

UNIDAD 4 CLASES Y OBJETOS

1. DEFINICIÓN DE UNA CLASE

2. DECLARACIÓN DE CLASES

3. MIEMBROS DE UNA CLASE

4. AMBITO REFERENTE A UNA CLASE

5. ESPECIFICADORES DE ACCESO

6. CREACIÓN DE OBJETOS

7. PUNTERO THIS

Programación I

8. CONSTRUCTORES Y DESTRUCTORES. ( MOVIMIENTO DE CLASES)

Apuntes del:

Ing. Jorge Eloy Toledo Coronel

Programación I DEFINICION DE CLASE Es un modelo que se utiliza para describir uno o

Programación I

DEFINICION DE CLASE

Es un modelo que se utiliza para describir uno o más objetos del mismo tipo. La comunicación con un objeto se realiza a través del paso de mensajes. El envío de un mensaje a una instancia de una clase produce la ejecución de un método (función miembro en C++).

DECLARACIÓN DE UNA CLASE

class contador{

long cuenta;

public:

void leervalor(long); long obtenervalor( );

};

Implementación de una clase

Void

{

contador::leerValor(long valor)

cuenta = valor,

}

long Contador::obtenerValor( )

{

return cuenta;}

}

Componentes de una definición de una clase

CLASE

Una clase es un tipo de dato que contiene uno o más elementos dato llamados miembro dato, y cero, una o más funciones que manipulan esos datos (llamados miembro función o funciones miembros). Una clase se puede definir con una estructura (estruct), una unión (unión) o una clase class.

La sintaxis de una clase es:

class nombre_clase

{

miembro_1;

//lista miembro

miembro_2;

miembro_3;

funcion_miembro_1( ); funcion_miembro_2( ); };

// funciones miembro conocidas //funciones como métodos

Los objetos o instancias de una clase se definen así:

Nombre_class_instancia_1;

Un puntero o referencia a un objeto proporciona medios indirectos para acceder a un objeto, sin embargo, el puntero o la propia referencia no es una instancia de una clase.

Apuntes del:

Ing. Jorge Eloy Toledo Coronel

Programación I Y una clase es sintacticamente igual a una estructura, con la única diferencia

Programación I

Y una clase es sintacticamente igual a una estructura, con la única diferencia de que en el tipo

class todos los miembros son por defecto privados mientras que en el tipo struct son por defecto públicas.

Así la estructura fecha antes declarada, se puede declarar con class:

class fecha{

int día;

int mes;

int anyo;

MIEMBROS PÚBLICOS Y PRIVADOS.

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.

class nombre { private:

// Miembros privados public:

// Miembros públicos

};

o

Pueden aparecer varias veces (y en distinto orden) las cláusulas public: y

private:

o Por defecto, si no se indica nada, los miembros son 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 (); };

Apuntes del:

Ing. Jorge Eloy Toledo Coronel

Programación I ÁMBITO DE UNA CLASE Una clase actúa como cualquier otro tipo de dato

Programación I

ÁMBITO DE UNA CLASE

Una clase actúa como cualquier otro tipo de dato con respecto al ámbito. Todos los miembros de una clase se dice que están en el ámbito de esa clase; cualquier miembro de una clase puede referenciar a cualquier otro miembro de la misma clase.

Las funciones miembro de una clase tienen acceso no restringido a los miembros dato de esa

clase. El acceso a los miembros dato y funciones de una clase fuera del ámbito de la clase está controlado por el programador. La idea es encapsular la estructura de datos y funcionalidad de una clase, de modo que el acceso a la estructura de datos de la clase desde fuera de la función

o innecesaria.

miembro

El nombre de la clase tiene que ser único dentro de su ámbito.

de

la

clase,

sea

limitada

ESPECIFICADORES DE ACCESO

Restricciones de acceso en C++

En C++ se puede especificar el acceso a los miembros de una clase utilizando los siguientes especificadores de acceso:

public: Interfaz de la clase.

private: Implementación de la clase.

protected: Implementación de la familia.

Estos especificadores no modifican ni la forma de acceso ni el comportamiento, únicamente controlan desde dónde se pueden usar los miembros de la clase:

public: desde cualquier sitio.

private: desde los métodos de la clase.

protected: desde los métodos de la clase y desde los métodos de las clases derivadas.

En ObjGraf.h:

//*************************************************/ // Definicion de la clase base TObjGraf //*************************************************/

class TObjGraf {

private:

// Puede acceder SOLO los objetos de esta clase.

int X;

int Y;

protected: // Pueden acceder los objetos de esta clase y sus descendientes.

TColor Color; TPaintBox * PaintBox;

public:

// Pueden usarlas todas.

// Constructor de objetos TObjGraf

TObjGraf (TPaintBox *_PaintBox, TColor _Color=clBlack, int _X=0, int _Y=0);

Apuntes del:

Ing. Jorge Eloy Toledo Coronel

// Otros metodos Programación I virtual void Mostrar ( void ) = 0 ; //

// Otros metodos

Programación I

virtual void Mostrar (void) = 0; // Método virtual puro

};

Modificar de la misma manera las clases TCirculo y TCuadrado para que sus propiedades Radio y Lado queden protegidas y los métodos públicos:

//*************************************************/ // Definicion de la clase derivada TCirculo. // Deriva de la clase base TObjGraf //*************************************************/

class TCirculo : public TObjGraf {

protected: // Pueden acceder los objetos de esta clase y sus descendientes.

int Radio;

public:

// Metodo constructor

TCirculo (TPaintBox *_PaintBox, TColor _Color=clBlack, int _X=0, int _Y=0, int _Radio=1);

void Mostrar (void); // Instanciacion del metodo virtual puro // de la clase TObjGraf

};

//*************************************************/ // Definicion de la clase derivada TCuadrado. // Deriva de la clase base TObjGraf //*************************************************/

class TCuadrado : public TObjGraf {

protected: // Pueden acceder los objetos de esta clase y sus descendientes.

int Lado;

public:

// Metodo constructor

TCuadrado (TPaintBox * _PaintBox, TColor _Color=clBlack, int _X=0, int _Y=0, int _Lado=1);

void Mostrar (void); // Instanciacion del metodo virtual puro // de la clase TObjGraf

};

Así, si en Ppal.cpp escribiéramos:

//--------------------------------------------------

void

fastcall

TPpalFrm::FormCreate (TObject *Sender)

{

Cir1->Mostrar();

// Se puede.

Apuntes del:

Ing. Jorge Eloy Toledo Coronel

Cir1->X = 10; } // No se puede porque X es private. //-------------------------------------------------- Programación

Cir1->X = 10;

}

// No se puede porque X es private.

//--------------------------------------------------

Programación I

En realidad estos tres especificadores de acceso son los propios de C++, pero en C++ Builder

existe otro adicional, que es el

modificador, porque su uso está restringido al IDE. Cuando en una clase veamos una sección

mantenidos

automáticamente por el IDE y no deberemos modificar nada en dicha sección, ya que de lo contrario los resultados pueden ser imprevisibles.

published.

los

miembros

No vamos a dar mucha importancia a este

contenidos

en

la

misma

son

published

quiere

decir

que

Es una buena técnica de programación no permitir el acceso público a las propiedades de un objeto, ya que si esto ocurriera podría peligrar la integridad del objeto. ¿Entonces cómo se puede cambiar el estado de un objeto desde el exterior?

1. Ofreciendo métodos (públicos) que se encarguen de modificar las propiedades (privadas) que se desee. De esta manera son los métodos los que acceden a las propiedades y el usuario de la clase sólo accede a través de ellos. Esta es la técnica clásica que se emplea en C++

A través de los métodos y de las propiedades "virtuales". Esta técnica es exclusiva de C++ Builder

CREACION DE OBJETOS

1. Creación Dinámica

Es la forma habitual de crear objetos en C++ Builder, y se realiza mediante el operador new .

Cuando usamos new para instanciar un objeto, se usa una variable que referencie o apunte al nuevo objeto creado (de otra manera éste quedaría totalmente inaccesible). En definitiva, se requiere la declaración previa de un puntero a objetos del tipo del que se va a crear.

En Ppal.cpp:

TObjGraf * ObjGraf; // Variable Global. // ObjGraf es un puntero a objetos de tipo TObjGraf

//--------------------------------------------------

void

{

fastcall

TPpalFrm::FormCreate(TObject *Sender)

ObjGraf = new TObjGraf;

}

//--------------------------------------------------

La forma de establecer el estado inicial o destruir las componentes de un objeto se estudiarán en el apartado dedicado a Constructores y Destructores

¡Cuidado! Cuando se utiliza esta forma de instanciación de clases es responsabilidad únicamente del programador la correcta destrucción de los mismos.

Apuntes del:

Ing. Jorge Eloy Toledo Coronel

2. Destrucción de objetos Programación I Cuando un objeto deja de ser útil hay que

2. Destrucción de objetos

Programación I

Cuando un objeto deja de ser útil hay que eliminarlo. De esta manera la aplicación recupera los recursos (memoria) que ese objeto había acaparado cuando se creó.

La destrucción de objetos creados en tiempo de ejecución con new se realiza mediante el operador delete.

En Ppal.cpp:

Pulsando dos veces en OnDestroy de la pestaña Events del editor de objetos de PpalFrm:

//--------------------------------------------------

void

{

fastcall

TPpalFrm::FormDestroy(TObject *Sender)

delete ObjGraf;

}

//--------------------------------------------------

EL PUNTERO THIS

Nunca se puede llamar a una función miembro privada de una clase a menos que se asocie con un objeto. En C cada vez que se utiliza un puntero para acceder a los miembros de una

estructura, debe utilizarse el operador de puntero (->) para acceder a los datos. ¿Cómo sabe una

una clase asociada con ella?

El método utilizado por C++ es añadir un argumento extra oculto a las funciones miembro. Este argumento es un puntero al objeto de la clase que lo enlaza con la función asociada y recibe un nombre especial denominado this.

función miembro

cuál

es

la

instancia

de

Dentro de una función miembro, this apunta al objeto asociado con la invocación de la función miembro. El tipo de this en una función miembro de una clase T es T *const es decir, un puntero constante a un objeto de tipo T.

Normalmente, el programador no necesita preocuparse por este puntero, ya que C++ realiza la operación automáticamente, haciendo el uso de this transparente a las funciones miembro que la utilizan. Dentro de una función miembro, se pueden hacer referencias a los miembros del objeto asociado a ella con el prefijo this y el operador de acceso ->. Sin embargo, este proceso no es necesario, ya que es redundante. Consideremos como ejemplo el constructor de una clase que manipula números complejos:

complejo::complejo (float a,float b)

{

}

real=a;

imag=b;

Este constructor se puede escribir:

complejo::complejo (float a,float b)

{

Apuntes del:

Ing. Jorge Eloy Toledo Coronel

this->real=a; this->imag=b; } this->nombre_miembro : apunta a un miembro *this : es el objeto total.

this->real=a;

this->imag=b;

}

this->nombre_miembro : apunta a un miembro

*this : es el objeto total. Es un valor constante

this : es la dirección del objeto apuntado

Programación I

CONSTRUCTORES Y DESTRUCTORES

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

se inicializan.

? ?El constructor de una clase es un método de esa clase, con el mismo nombre 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 '~NombreClase'.

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.

Apuntes del:

Ing. Jorge Eloy Toledo Coronel

class conjuntoInt { Programación I public: ~ conjuntoInt () {cout<<"Nada";} // Destructor, irrelevante

class conjuntoInt {

Programación I

public:

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

};

Constructores y Destructores (Inicialización de Clases I)

Son métodos que permiten establecer el estado inicial y final de un objeto. Los constructores se pueden definir con un conjunto de argumentos arbitrario, pero no pueden devolver nada. Y los destructores no pueden recibir ni devolver ningún valor.

El constructor debe llamarse igual que la clase, y el destructor el nombre de la clase precedido del carácter ~

Un constructor se ejecuta cuando se crea un nuevo objeto: 1) por declaración, ó 2) cuando se crea dinámicamente con el operador new. Un destructor se ejecuta cuando el objeto deja de existir: 1) porque su ámbito acaba, ó 2) cuando se libera explícitamente con el operador delete.

En ObjGraf.h:

class TObjGraf {

// Constructor de objetos TObjGraf

TObjGraf (TPaintBox *_PaintBox, TColor _Color=clBlack, int _X=0, int _Y=0);

// El destructor sería: ~ TObjGraf (void );

};

En ObjGraf.cpp:

TObjGraf :: TObjGraf (TPaintBox * _PaintBox, TColor _Color, int _X, int _Y)

{

PaintBox = _PaintBox;

Color

= _Color;

X

= _X;

Y

= _Y;

}

En Ppal.cpp:

void

{

fastcall

TPpalFrm::FormCreate(TObject *Sender)

ObjGraf = new TObjGraf (PaintBox, clRed, 10, 10);

}

Importante: No es necesario escribir un destructor salvo si el objeto requiere memoria dinámica adicional. De ser así, la tarea del destructor será, básicamente, liberar la memoria dinámica que ocupa el objeto que se va a destruir.

Apuntes del:

Ing. Jorge Eloy Toledo Coronel