¡Descarga Programación Orientada a Objetos en C++: Conceptos Fundamentales y Ejemplos y más Apuntes en PDF de Programación Orientada a Objetos solo en Docsity!
Notas de Programación Orientada a Objetos. ver. 1.0 *
Carlos Alberto Fernández y Fernández.
Instituto de Electrónica y computación.
UNIVERSIDAD TECNOLÓGICA DE LA MIXTECA.
- Características de C++................................................................................................................ Contenido.
- Comentarios en C++.
- Flujo de entrada/salida..............................................................................................................
- Funciones en línea....................................................................................................................
- Declaraciones de variables.........................................................................................................
- Operador de resolución de alcance..............................................................................................
- Valores por Default...................................................................................................................
- Parámetros por referencia.
- Variables de referencia...........................................................................................................
- Asignación de memoria en C++ (new y delete)
- Plantillas o "templates"
- Introducción a la programación orientada a objetos. [6][7]
- Programación no estructurada....................................................................................................
- Programación procedural.
- Programación modular..............................................................................................................
- Datos y Operaciones separados
- Programación orientada a objetos...............................................................................................
- Tipos de Datos Abstractos..........................................................................................................
- Los Problemas......................................................................................................................
- Tipos de Datos Abstractos y Orientación a Objetos.....................................................................
- Conceptos de básicos de objetos.................................................................................................
- Abstracción de datos: Clases y objetos. ........................................................................................
- Clases. ..................................................................................................................................
- Objetos e instancias. ................................................................................................................
- Instanciación. ......................................................................................................................
- Clases en C++........................................................................................................................
- Miembros de una clase. ............................................................................................................
- Atributos miembro. ..............................................................................................................
- Métodos miembro. ...............................................................................................................
- Un primer acercamiento al acceso a miembros...........................................................................
- Objetos de clase. .....................................................................................................................
- Alcance de Clase. ....................................................................................................................
- Sobrecarga de operaciones........................................................................................................
- Constructores y destructores......................................................................................................
- Constructor. ........................................................................................................................
- Destructor...........................................................................................................................
- Miembros estáticos. .................................................................................................................
- Objetos constantes...................................................................................................................
- Objetos compuestos. ..................................................................................................................
- Asociaciones entre clases. ...........................................................................................................
- Multiplicidad de una asociación.................................................................................................
- Constructor de Copia...............................................................................................................
- Sobrecarga de operadores. .........................................................................................................
- Algunas restricciones:..............................................................................................................
- Funciones amigas (friends). ........................................................................................................
- Herencia...................................................................................................................................
- Implementación en C++. ..........................................................................................................
- Control de Acceso a miembros. ..................................................................................................
- Control de acceso en herencia.................................................................................................
- Manejo de objetos de la clase base como objetos de una clase derivada y viceversa. ............................
- Constructores de clase base.......................................................................................................
- Redefinición de métodos ...........................................................................................................
- Herencia Múltiple....................................................................................................................
- Constructores. .....................................................................................................................
- Funciones virtuales y polimorfismo. ............................................................................................
- Clase abstracta y clase concreta.................................................................................................
- Polimorfismo. .........................................................................................................................
- Destructores virtuales. .............................................................................................................
- Bibliografía ..............................................................................................................................
Funciones en línea.
Las funciones en línea, se refiere a introducir un calificador inline a una función de manera que le sugiera al compilador que genere una copia del código de la función en lugar de la llamada.
Ayuda a reducir el número de llamadas a funciones reduciendo el tiempo de ejecución en algunos casos, pero en contraparte puede aumentar el tamaño del programa.
A diferencia de las macros, las funciones inline si incluyen verificación de tipos y son reconocidas por el depurador.
Las funciones inline deben usarse sólo para funciones chicas que se usen frecuentemente.
El compilador desecha las solicitudes inline para programas que incluyan un ciclo, un switch o un goto. Tampoco si no tienen return (aunque no regresen valores) o si contienen variables de tipo static. Y lógicamente no genera una función inline para funciones recursiovas.
Declaración:
Inline <declaración de la función>
Ejemplo:
Inline float suma (float a, float b) { Return a+b; }
inline int max( int a, int b) { return (a > b)? a : b; }
Declaraciones de variables.
Mientras que en C, las declaraciones deben ir en la función antes de cualquier línea ejecutable, en C++ pueden ser introducidas en cualquier punto, con la condición de que la declaración esté antes de la utilización de lo declarado.
También puede declararse una variable en la sección de inicialización de la instrucción for, pero es incorrecto declarar una variable en la expresión condicional del while, do-while, for, if o switch.
El alcance de las variables en C++ es por bloques. Una variable es vista a partir de su declaración y hasta la llave } del nivel en que se declaró. Lo cual quiere decir que las instrucciones anteriores a su declaración no pueden hacer uso de la variable ni después de finalizado el bloque.
Operador de resolución de alcance.
Se puede utilizar el operador de resolución de alcance :: se refiere a una variable, con un alcance de archivo (variable global).
Esto le permite al identificador ser visible aún si el identificador se encuentra oculto. Ejemplo:
Float h;
Void g(int h) { Float a; Int b;
A=::h; // a se inicializa con la variable global h
B=h; // b se inicializa con la variable local h }
Valores por Default.
Las funciones en C++ pueden tener valores por default. Estos valores son los que toman los parámetros en caso de que en una llamada a la función no se encuentren especificados.
Los valores por omisión deben encontrarse en los parámetros que estén más a la derecha. Del mismo modo en la llamada se deben empezar a omitir los valores de la extrema derecha.
C++ no permite la llamada omitiendo un valor antes de la extrema derecha de los argumentos:
punto( , 8);
El operador new crea automáticamente un área de memoria del tamaño adecuado. Si no se pudo asignar le memoria se regresa un apuntador nulo (NULL ó 0). Nótese que en C++ se trata de operadores que forman parte del lenguaje, no de funciones de librería. El operador delete libera la memoria asignada previamente por new. No se debe tratar de liberar memoria ya liberada o no asignada con new. Es posible hacer asignaciones de memoria con inicialización:
Int *max= new int (1000);
También es posible crear arreglos dinámicamente.
Char *cad; Cad= new char [30];
delete [] cad;
Usar delete sin los corchetes puede no liberar adecuadamente la memoria, sobre todo si son elementos de un tipo definido por el usuario.
Plantillas o "templates"
Cuando las operaciones son idénticas pero requieren de diferentes tipos de datos, podemos usar lo que se conoce como templates o plantillas de función.
El termino de plantilla es porque el código sirve como base (o plantilla) a diferentes tipos de datos. C++ genera al compilar el código objeto de las funciones para cada tipo de dato involucrado en las llamadas.
Las definiciones de plantilla se escriben con la palabra clave template, con una lista de parámetros formales entre < >. Cada parámetro formal lleva la palabra clave class.
Cada parámetro formal puede ser usado para sustituir a: tipos de datos básicos, estructurados o definidos por el usuario, tipos de los argumentos, tipo de regreso de la función y para variables dentro de la función.
Introducción a la programación orientada a objetos. [6][7]
Programación no estructurada.
Comúnmente, las personas empiezan a aprender a programar escribiendo programas pequeños y sencillos consistentes en un solo programa principal. Aquí "programa principal" se refiere a una secuencia de comandos o instrucciones que modifican datos que son a su vez globales en el transcurso de todo el programa.
Programación procedural.
Con la programación procedural se pueden combinar las secuencias de instrucciones repetitivas en un solo lugar.
Una llamada de procedimiento se utiliza para invocar al procedimiento. Después de que la secuencia es procesada, el flujo de control procede exactamente después de la posición donde la llamada fue hecha
Al introducir parámetros así como procedimientos de procedimientos ( subprocedimientos) los programas ahora pueden ser escritos en forma más estructurada y con menos errores.
Por ejemplo, si un procedimiento ya es correcto, cada vez que es usado produce resultados correctos. Por consecuencia, en caso de errores, se puede reducir la búsqueda a aquellos lugares que todavía no han sido revisados.
De este modo, un programa puede ser visto como una secuencia de llamadas a procedimientos. El programa principal es responsable de pasar los datos a las llamadas individuales, los datos son procesados por los procedimientos y, una vez que el programa ha terminado, los datos resultantes son presentados. Así, el flujo de datos puede ser ilustrado como una gráfica jerárquica, un árbol.
Programación modular.
En la programación modular, los procedimientos con una funcionalidad común son agrupados en módulos separados. Un programa por consiguiente, ya no consiste solamente de una sección. Ahora está dividido en varias secciones más pequeñas que interactúan a través de llamadas a procedimientos y que integran el programa en su totalidad.
Cada módulo puede contener sus propios datos. Esto permite que cada módulo maneje un estado interno que es modificado por las llamadas a procedimientos de ese módulo. Sin embargo, solamente hay un estado por módulo y cada módulo existe cuando más una vez en todo el programa.
Datos y Operaciones separados
La separación de datos y operaciones conduce usualmente a una estructura basada en las operaciones en lugar de en los datos : Los Módulos agrupan las operaciones comunes en forma conjunta.
El modelo define una perspectiva abstracta del problema. Esto implica que el modelo se enfoca solamente en aspectos relacionados con el problema y que tú tratas de definir propiedades del problema. Estas propiedades incluyen
- los datos que son afectados
- las operaciones que son identificadas
por el problema.
Para resumir, la abstracción es la estructuración de un problema nebuloso en entidades bien definidas por medio de la definición de sus datos y operaciones. Consecuentemente, estas entidades combinan datos y operaciones. No están desacoplados unos de otras.
Tipos de Datos Abstractos y Orientación a Objetos
Los TDAs permiten la creación de instancias con propiedades bien definidas y comportamiento bien definido. En orientación a objetos, nos referimos a los TDAs como clases. Por lo tanto, una clase define las propiedades de objetos instancia en un ambiente orientado a objetos.
Los TDAs definen la funcionalidad al poner especial énfasis en los datos involucrados, su estructura, operaciones, así como en axiomas y precondiciones. Consecuentemente, la programación orientada a objetos es "programación con TDAs" : al combinar la funcionalidad de distintos TDAs para resolver un problema. Por lo tanto, instancias (objetos) de TDAs (clases) son creados dinámicamente, usados y destruídos.
Conceptos de básicos de objetos.
La programación tradicional separa los datos de las funciones, mientras que la programación orientada a objetos define un conjunto de objetos donde se combina de forma modular los datos con las funciones.
Aspectos principales:
- Objetos.
- El objeto es la entidad básica del modelo orientado a objetos.
- El objeto integra una estructura de datos (atributos) y un comportamiento (operaciones).
- Se distinguen entre sí por medio de su propia identidad, aunque internamente los valores de sus atributos sean iguales.
- Clasificación.
- Las clases describen posibles objetos, con una estructura y comportamiento común.
- Los objetos que contienen los mismos atributos y operaciones pertenecen a la misma clase.
- La estructura de clases integra las operaciones con los atributos a los cuales se aplican.
- Instanciación.
- El proceso de crear objetos que pertenecen a una clase se denomina instanciación. (El objeto es la instancia de una clase).
- Pueden ser instanciados un número indefinido de objetos de cierta clase.
- Generalización.
- En una jerarquía de clases, se comparten atributos y operaciones entre clases basados en la generalización de clases.
- La jerarquía de generalización se construye mediante la herencia.
- Las clases más generales se conocen como superclases. (clase padre)
- Las clases más especializadas se conocen como subclases (clases hijas).
- La herencia puede ser simple o múltiple.
- Abstracción.
- La abstracción se concentra en lo primordial de una entidad y no en sus propiedades secundarias.
- Además en lo que el objeto hace y no en cómo lo hace.
- Se da énfasis a cuales son los objetos y no cómo son usados. Logrando el desarrollo de sistemas más estables.
- Encapsulación.
- Encapsulación o encapsulamiento es la separación de las propiedades externas de un objeto de los detalles de implementación internos del objeto.
- Al separar la interfaz del objeto de su implementación, se limita la complejidad al mostrarse sólo la información relevante.
- Disminuye el impacto a cambios en la implementación, ya que los cambios a las propiedades internas del objeto no afectan su interacción externa.
- Modularidad.
- El encapsulamiento de los objetos trae como consecuencia una gran modularidad.
- Cada módulo se concentra en una sola clase de objetos.
- Los módulos tienden a ser pequeños y concisos.
- La modularidad facilita encontrar y corregir problemas.
- La complejidad del sistema se reduce facilitando su mantenimiento.
- Extensibilidad.
- La extensibilidad permite hacer cambios en el sistema sin afectar lo que ya existe.
- Nuevas clases pueden ser definidas sin tener que cambiar la interfaz del resto del sistema.
- La definición de los objetos existentes puede ser extendida sin necesidad de cambios más allá del propio objeto.
- Polimorfismo.
- El polimorfismo es la característica de definir las mismas operaciones con diferente comportamiento en diferentes clases.
- Se permite llamar una operación sin preocuparse de cuál implementación es requerida en que clase, siendo responsabilidad de la jerarquía de clases y no del programador.
- Reusabilidad de código.
- La orientación a objetos apoya el reuso de código en el sistema.
- Los componentes orientados a objetos se pueden utilizar para estructurar librerías resuables.
- El reuso reduce el tamaño del sistema durante la creación y ejecución.
- Al corresponder varios objetos a una misma clase, se guardan los atributos y operaciones una sola vez por clase, y no por cad objeto.
- La herencia es uno de los factores más importantes contribuyendo al incremento en el reuso de código dentro de un proyecto.
Clases en C++.
Una clase entonces permite encapsular la información a través de atributos y métodos que utilizan la información, ocultando la información y la implementación del comportamiento de las clases.
La definición de una clase define nuevos TDAs y la definición en C++ consite de la palabra reservada class, seguida del nombre de la clase y finalmente el cuerpo de la clase encerrado entre llaves y finalizando con ;.
El cuerpo de la clase contiene la declaración de los atributos de la clase (variables) y la declaración de los métodos (funciones). Tanto los atributos como los métodos pertenecen exclusivamente a la clase y sólo pueden ser usados a través de un objeto de esa clase.
Sintaxis: class <nombre_clase> { };
Ejemplo:
class cEjemplo1 { int x; float y; void fun(int a, float b) { x=a; y=b; } };
Miembros de una clase.
Una clase está formada por un conjunto de miembros que pueden ser datos, funciones, clases anidadas, enumeraciones, tipos de dato, etc. ( amigos ). Por el momento nos vamos a centrar en los datos y las funciones (atributos y métodos.
Es importante señalar que un miembro no puede ser declarado más de una vez. Tampoco es posible añadir miembros después de la declaración de la clase.
Ejemplo:
class cEjemplo2{ int i; int i; //error int j; int func(int, int); }
Atributos miembro.
Todos los atributos que forman parte de una clase deben ser declarados dentro de la misma.
Métodos miembro.
Los métodos al igual que los atributos, deber ser definidos en la clase, pero el cuerpo de la función puede ir dentro o fuera de la clase. Si un método se declara completo dentro de la clase, se considera como inline (puede ser en línea).
La declaración dentro de la clase no cambia con respecto a la declaración de una función, salvo que se hace dentro de la clase. Recordemos el ejemplo inicial pero ahora modificado con el cuerpo del méotdo fuera del cuerpo de la clase.
Ejemplo: //código en ejemplo3.h class cEjemplo3 { public: int x; float y; int funX(int a) { x=a; return x; } float funY(float); };
Podemos ver que en la definición de la clase se incluye un método en línea y un prototipo de otro método. Para definir un método miembro de una clase se debe escribir antes del nombre del método la clase con la que el método esta asociado. Para esto se ocupa el operador de resolución de alcance (o de ámbito) ::.
Continuación del ejemplo:
float cEjemplo3::funY(float b){ y=b; return y; }
Reiteramos que al declarar los métodos fuera de la clase no puede mencionarse la declaración de un método que no esté contemplado dentro de la clase, pues entonces cualquiera podría ganar acceso a la clase con sólo declarar una función adicional.
Ejemplo: //error en declaración de un método class x{ public: int a; f(); };
int x::g() { //error sólo se puede con f() return a*=3.1234; }
La declaración de una función miembro es considerada dentro del ámbito de su clase. Lo cual significa que puede usar nombres de miembros de la clase directamente sin usar el operador de acceso de miembro de la clase.
Ya se ha visto como definir una clase, declarando sus atributos y sus operaciones, mismas que pueden ir dentro de la definición de la clase (inline) o fuera. Ahora vamos a ver como es posible crear objetos o instancias de esa clase.
Hay que recordar que una de las características de los objetos es que cada uno guarda un estado particular de acuerdo al valor de sus atributos^2.
Lo más importante de los LOO es precisamente el objeto, el cual es una identidad lógica que contiene datos y código que manipula esos datos. [5]
En C++, un objeto es una variable de un tipo definido por el usuario.[5]
Alcance de Clase.
El nombre de un miembro de una clase es local a la clase. Las funciones no miembros se definen en un alcance de archivo. Dentro de la clase los miembros pueden ser accesados directamente por todos los métodos miembros. Fuera del alcance la clase, los miembros de la clase se pueden utilizar seguidos del operador de selección de miembro de punto. ó operador de selección de miembro de flecha ‡ , posteriormente al nombre de un objeto de clase. Ejemplo:
Class cMiClase{ Public: Static int valor(); //no usar la declaración static todavía
Int otraFuncion(); }
void main () { cMiClase cM;
cM.otraFuncion();
xMiClase::valor(); }
(^2) A diferencia de la programación modular, donde cada módulo tiene un solo estado. Aunque está
característica se puede lograr en la programación modular.
Sobrecarga de operaciones.
En C++ es posible tener el mismo nombre para una operación con la condición de que tenga parámetros diferentes. La diferencia debe de ser al menos en el tipo de datos. Al menos un parámetro debe ser diferente.
Si se tienen dos o más operaciones con el mismo nombre y diferentes parámetros se dice que dichas operaciones están sobrecargadas.
El compilador sabe que operación ejecutar a través de la firma de la operación, que es una combinación del nombre de la operación y el número y tipo de los parámetros.
El tipo de regreso de la operación puede ser igual o diferente.
La sobrecarga de operaciones sirve para hacer un código más legible y modular. La idea es utilizar el mismo nombre para operaciones relacionadas. Si no tienen nada que ver entonces es mejor utilizar un nombre distinto.
Ejemplo:
class cMiClase{ int x; Public: void modifica() { X++; } void modifica(int y){ x=y*y; }
Ejemplo 2: //fuera de POO #include <iostream.h>
int cuadrado(int i){ return ii; } double cuadrado(double d){ return dd; }
void main() { cout<<"10 elevado al cuadrado: "<<cuadrado(10)<<endl; cout<<"10.5 elevado al cuadrado: "<<cuadrado(10.5)<<endl; }
Int get( ); };
cCola::~cCola( ){ cout<<"cola destruida\n"; }
Miembros estáticos.
Cada objeto tiene su propio estado, pero a veces es necesario tener valores por clase y no por objeto. En esos casos es necesario tener atributos estáticos que sean compartidos por todos los objetos de la clase.
Existe solo una copia de un miembro estático y no forma parte de los objetos de la clase.
ejemplo: class cObjeto{ private: char nombre[10]; static int numObjetos; public: cObjeto(char *cadena=NULL); ~cObjeto(); };
cObjeto::cObjeto(char *cadena){ if(cadena!=NULL) strcpy(nombre, cadena); else nombre=NULL; numObjetos++; } cObjeto::~cObjeto(){ numObjetos--; }
Un miembro estático es accesible desde cualquier objeto de la clase o mediante el operador de resolución de alcance binario (::) y el nombre de la clase, dado que existen aunque no haya instancias de la clase. Sin embargo, el acceso sigue restringido bajo las reglas de acceso a miembros. Si se quiere accesar a un miembro estático que es privado deberá hacerse mediante un método público. Si no existe ningunaq instancia de la clase entonces deberá ser por medio de un método público y estático.
Un método estático solo puede tener acceso a miembros estáticos. Los atributos estáticos deben de ser inicializados al igual que los atributos constantes, fuera de la declaración de la clase. Ejemplo: int cClase::atributo=0; int const cClase::ATRCONST=50;
Objetos constantes.
Es posible tener objetos de tipo constante, los cuales no podrán ser modificados en ningún momento.^3 Tratar de modificar un objeto constante se detecta como un error en tiempo de compilación.
Sintaxis: const ; const cHora h1(9, 30, 20);
Para estos objetos, algunos compiladores llegan a ser tan rígidos en el cumplimiento de la instrucción, que no permiten que se hagan llamadas a métodos sobre esos objetos. En el caso de C++ de Borland, el compilador únicamente manda una advertencia y permite que se ejecute, pero advierte que debe ser considerado como un error.
Sin embargo, es posible que se quiera consultar al objeto mediante llamadas a métodos get, para esto se pueden declarar métodos con la palabra reservada const, para permitirles actuar libremente sobre los objetos sin modificarlo. La sintaxis es añadir después de la lista de parámetros la palabra reservada conts en la declaración y en su definición.
Sintaxis: Declaración: (<parámetros>) const;
Definición del método fuera de la declaración de la clase: :: (<parámetros>) const { <código> }
Definición del método dentro de la declaración de la clase: (<parámetros>) const { <código> }
Aunque el compilador de borland permite usar los métodos constantes de manera indiferente para objetos constantes y no constantes siempre y cuando no modifiquen al objeto; sin embargo, algunos compiladores restringen el uso de métodos constantes a objetos constantes. Para solucionarlo es posible sobrecargar el método con la única diferencia de la palabra const, aunque el resto de la firma del método sea la misma.
Los constructores no necesitan la declaración const, puesto que deben poder modificar al objeto.
(^3) Ayuda a cumplir el principio del mínimo privilegio, donde se debe restringir al máximo el acceso a los datos
cuando este acceso estaría de sobra. [1]
