Programacin II Bloque I: Introduccin al desarrollo Orientado a Objetos Tema 1: Clases y objetos

Contenido
Programacin II .....................................................................................................................1 Bloque I: Introduccin al desarrollo Orientado a Objetos .....................................................1 Tema 1: Clases y objetos.......................................................................................................1 1Introduccin a la programacin orientada a objetos ......................................................1 2Estructura de un programa bsico en C++.....................................................................2 3E/S estndar....................................................................................................................2 4Clases y objetos en C++ .................................................................................................2 5Sintaxis de la declaracin de una clase: ........................................................................4 6Constructores y destructores ..........................................................................................6 6.1Constructores...........................................................................................................6 6.2Destructores.............................................................................................................7 7Argumentos predeterminados.........................................................................................9 8Funciones inline.............................................................................................................10 9Asignacin de objetos ...................................................................................................11 10Paso de objetos a funciones .......................................................................................11 11Colecciones de objetos ...............................................................................................12 12La clase estndar string de C++ .................................................................................13 12.1Lectura de una cadena en C++............................................................................14 12.2Funciones miembro..............................................................................................15

Introduccin a la programacin orientada a objetos

Imperativo: Fortran, Pascal , C Declarativo: Funcional: Lisp Lgico: Prolog Orientado a Objetos: Smalltalk, Eiffel, Java, C++,...

Paradigmas de programacin :

As, un Programa Orientado a Objetos es un conjunto de objetos que interactan entre s a travs del intercambio de mensajes . Para disear este tipo de programas, se emplean lenguajes de modelado como UML (Lenguaje de Modelado Unificado), ajustndose de forma natural a un sistema orientado a objetos. Finalmente, es interesante destacar que la programacin orientada a objetos se basa en dos aspectos clave: Reusabilidad Extensibilidad

Estructura de un programa bsico en C++

Un programa cualquier se compone de varias partes: la de includes, donde se especifica qu otras libreras se van a referenciar. La parte de declaraciones, donde se incluirn las declaraciones de tipos, y finalmente la funcin main(), que siempre debe existir como punto de entrada del programa.
#include <iostream> #include <cstdlib> using namespace std; // Declaraciones de tipos int main() { cout << PRO II << endl; return EXIT_SUCCESS; }

E/S estndar

La entrada estndar se define como cin, mientras que la salida estndar es cout. La salida estndar de errores es cerr. Para poder hacer lectura y escritura de los flujos de entrada y salida estndar, se utilizan dos operadores, << y >>, llamados respectivamente operadores de insercin y extraccin.
int main() { int x; cout << Introduce tu edad: ; // Pide la edad cin >> x; cout << Tienes << x << aos << endl; }

Clases y objetos en C++

La programacin orientada a objetos se basa en la mayora de lenguajes de programacin en las clases. La clase es similar a una plantilla a partir de la cual se crean nuevos objetos. Esos objetos comparten caractersticas comunes entre s, aunque no sean iguales. Por ejemplo, todos los coches tienen puertas y son de algn color, pero no todos tienen el mismo nmero de puertas ni el mismo color. La clase se equipara a un tipo del lenguaje, definido por el programador, en C++, y la mayora de lenguajes de programacin. Permite describir objetos similares mediante la definicin de su estructura (estado) y de su comportamiento. Ejemplo: existen rectngulos de varios tamaos, pero todos se definen por su ancho y alto (atributos comunes), y sus reas se calculan de forma comn (comportamiento). Es un tipo de dato (plantilla) definido por el usuario, donde se especifica con un

conjunto de variables internas (atributos) y un conjunto de operaciones (mtodos o funciones miembro), el estado y el comportamiento respectivamente, de un grupo de objetos. Es un mecanismo para la creacin (instanciacin) de objetos (fabrica de objetos). Los objetos (tambin llamados instancias) en C++ se equiparan a las variables, de tal manera que un objeto es una variable de su tipo (clase). Instancia de una clase que posee un estado y un comportamiento. Ejemplo: un rectngulo concreto con un alto y ancho determinado, y por lo tanto con un rea especfica. El mensaje es la forma en la que los objetos pueden comunicarse en un sistema orientado a objetos. Mecanismo de comunicacin entre objetos, Una peticin de un objeto a otro objeto al que le solicita ejecutar uno de sus mtodos. As, la interfaz de un objeto es el conjunto de mensajes que acepta . La definicin de una clase conlleva la creacin de un tipo, y no se reserva espacio en memoria. Adems de un nombre, una clase debe tambin declarar sus miembros, bien sean datos (atributos o datos miembro), o mtodos (o funciones miembro). Tipos de miembros de una clase en C++: Variables miembro (o datos miembro): almacenan los datos (atributos) de los objetos. Funciones miembro: realizan las acciones sobre los objetos (mtodos).

Sintaxis de la declaracin de una clase:

La sintaxis de declaracin de una clase es como sigue:

class nombre_clase { [ public: ] < variables y funciones pblicas > [ protected: ] < variables y funciones protegidas > [ private: ] < variables y funciones privadas> };

Ejemplo:
class Rectangulo { public: // ms cosas... void setLado1(double l1); double calcularArea(); private: double lado1; double lado2; };

La implementacin de un mtodo se realiza de la misma forma que una funcin, slo que anteponiendo el nombre de la clase al nombre de la funcin miembro. Otra diferencia es que los mtodos (y no las funciones normales), pueden llevar el modificador const a la derecha, indicando que el mtodo no modifica los atributos del objeto. Un mtodo const slo puede llamar, de ser necesario, a otros mtodos const. Sintaxis
tipo nombre_clase::nombre_funcion( lista_parametros ) [const] { < implementacin > }

Ejemplo:
double Rectangulo::calcularArea() const { return lado1 * lado2; } void Rectangulo::setLado1(double l1) { lado1 = l1; }

Visibilidad de (niveles de acceso a ) los miembros de una clase: Pblico: es accesible desde cualquier punto donde sea accesible un objeto de dicha clase (Interfaz del objeto).

Privado/protegido: proporcionan ocultamiento de informacin, puesto que slo son accesibles por los propios miembros de la clase, pero no desde funciones externas a dicha clase (privado), o slo son accesibles desde funciones miembro de la misma clase o de clases derivadas de la misma.

Una vez creada la clase, se pueden definir (o instanciar) objetos de ella. Lgicamente, en el momento de crear el primer objeto, ya se est consumiendo memoria.
nombre_clase nombre_obj;

Ejemplo:
int main() { Rectangulo r1; // ms cosas... }

Para acceder a los miembros pblicos de un objeto, se indica el nombre del objeto, un punto, u el nombre del miembro. Si el miembro es un mtodo, se aade entre parntesis la lista de argumentos.
objeto.funcion ( argumentos );

Ejemplo:
int main() { Rectangulo r1; r1.setLado1( 5 ); // ms cosas... }

Un ejemplo ms completo podra ser el que figura a continuacin. En las clases tambin pueden introducirse constantes, como PrecioPorHora. El nico inconveniente es que normalmente cada objeto tendra su propia memoria dedicada a la constante, estando duplicada en cada objeto, cuando en realidad su valor no va a cambiar nunca. De ah que se emplee el modificador static, que en este contexto significa que todos los objetos compartirn una sola versin de la constante, ahorrando por tanto memoria.
class Empleado { public: static const unsigned int PrecioPorHora = 10; void calcularSalario(unsigned int nh); float getSalario() const; private: char dni[ 10 ]; unsigned int numHoras; float salario; }; void Empleado::calcularSalario(unsigned int nh) { numHoras = nh;

salario = PrecioPorHora * numHoras; } float Empleado::consultarSalario() const { return salario; } int main() { Empleado pepe; pepe.calcularSalario ( 34 ); cout << " Salario semanal "; << pepe.consultarSalario() << endl; }

6 6.1

Constructores y destructores Constructores

Constructor de una clase: es una funcin miembro que se invoca automticamente cuando se crea un objeto de la clase (instancia). Permite inicializar el estado del objeto. Tiene el mismo nombre que la clase y no devuelve ningn valor . Sintaxis
class nombre_clase { public: nombre_clase ( lista_parametros ); // otros miembros... }; nombre_clase::nombre_clase(lista_parametros) { < implementacin > }

En el momento de crear el objeto, se aade una lista encerrada entre parntesis con los parmetros dedicados al constructor. Si el constructor no existe o no necesita parmetros, entonces se omite dicha lista. Los constructores sin parmetros se denominan constructores por defecto, mientras los constructores con parmetros son parametrizados. Los parmetros de los constructores funcionan como los parmetros de cualquier otra funcin: admiten cualquier expresin.
nombre_clase nombre_objeto[( lista de parmetros )];

Ejemplo
class Rectangulo { public: Rectangulo(double l1, double l2); double getLado1() const;

double double private: double double };

getLado2() const; calcularArea() const; lado1; lado2;

Rectangulo::Rectangulo(double l1, double l2) { lado1 = l1; lado2 = l2; } double Rectangulo::getLado1() const { return lado1; } double Rectangulo::getLado2() const { return lado2; } int main() { Rectangulo r1( 5, 6 ); cout << Superficie: << r1.calcularArea() << endl; }

6.2

Destructores

Destructor de una clase: es una funcin miembro que se invoca automticamente cuando se destruye un objeto. No reciben ningn parmetro y no devuelven ningn valor. Es necesario tener en cuenta que un objeto, creado como variable local en una funcin, se destruye al salir de su mbito. Un objeto creado como variable global (tcnica muy desaconsejada) slo se destruye al finalizar el programa. Los destructores se utilizan cuando es necesario liberar algn recurso, pues se ejecutan justo antes de que el objeto se elimine. Un objeto tpicamente adquiere recursos en el constructor. Entonces se hace necesario crear un destructor para liberar esos recursos. Por ejemplo, una clase podra abrir en su constructor un archivo, siendo por tanto necesario cerrarlo en el destructor. Tiene el mismo nombre de la clase precedido del smbolo ~ (ASCII 126) . Sintaxis
class nombre_clase { public: ~nombre_clase(); // ms cosas... }; nombre_clase::~nombre_clase() {

< implementacin > }

Ejemplo
/** La clase Log crea un archivo en el que se almacenan mensajes de eventos. */ class Log { public: Log(char nombre[]); ~Log(); void escribe(char msg[]); private: FILE * f; }; Log::Log(char nombre[]) { f = fopen( nombre, wt ); } Log::~Log() { fclose( f ); } void Log::escribe(char mensaje[]) { fprintf( f, %s\n, mensaje ); } int main() { Log l( log.txt ); l.escribe( comienza el programa ); l.escribe( termina el programa ); }

Ejemplo
class Empleado { public: Empleado(char d[ ]); private: char dni [ 10 ]; }; Empleado::Empleado(char d [ ]) { strcpy ( dni, d ); } int main() { Empleado pepe ( 12345678 ); }

Argumentos predeterminados

Los argumentos predeterminados son los que se asumen, a la hora de realizar la llamada a una funcin, cuando no se indica nada (es decir, por omisin, por defecto o implcitos) . a) Con el operador de asignacin se le asigna el valor por defecto a un argumento predeterminado; b) Los argumentos predeterminados se deben especificar en el prototipo de la funcin; c) Los valores que se les pueden asignar a los argumentos predeterminados son constantes, variables globales o llamadas de funcin; d) Los argumentos predeterminados siempre se deben pasar por valor; e) Los argumentos predeterminados deben ser los ltimos de la lista de parmetros de la funcin. Ejemplo
#include <iostream> using namespace std; int volumen(int longitud = 1, int altura = 1, int anchura = 1); void main() { cout << cout << << << }

"Volumen predeterminado : << volumen() << endl; "Volumen con una longitud de 5, una altura de 10 y una anchura de 3 : volumen ( 5, 10, 3 );

int volumen(int longitud, int altura, int anchura) { return longitud * altura * anchura; }

Se pueden utilizar parmetros por defecto a la hora de definir un constructor, al igual que en cualquier otra funcin. Un constructor con todos sus argumentos con valores por defecto puede funcionar como un constructor por defecto. Ejemplo
class Empleado { public: Empleado (char d[], float r = 1); ~Empleado ( ); void visualizarDatos() { cout << "DNI: " << dni << " Retencion: " << retencion << endl; } private: char dni [ 10 ]; float retencion; };

Empleado::Empleado(char d[], float r) { strcpy ( dni, d ); retencion = r; } Empleado::~Empleado ( ) { cout << "\nDestructor de la clase empleado"; } Empleado pepe ( "12345678 ); Empleado juan ( "87654321z", 0.18 ); int main() { pepe.visualizarDatos ( ); juan.visualizarDatos ( ); }

Funciones inline

Funciones inline (insertadas o en lnea): funciones cuyo cdigo se inserta en la llamada. Se trata de una solicitud al compilador, no se garantiza que vaya a suceder. La llamada a esa funcin se sustituye por el propio cdigo de la funcin: aumenta la rapidez de ejecucin pero tambin el tamao del ejecutable. Sintaxis
inline tipo nombre_funcion ( lista_parametros ) { }

Las funciones miembro tambin pueden ser funciones inline. Se trata de una funcin miembro cuya implementacin va dentro de la definicin de una clase. Este simple hecho implica que sea inline. Ntese que en este caso no conlleva modificador de ningn tipo. Sintaxis:
class nombre_clase { public: tipo nombre_funcion ( lista_parametros ) { < implementacin > } ... };

Si la implementacin de la funcin miembro se realiza fuera de la definicin de la clase, se denomina funcin fuera de lnea. No obstante, mediante el modificador inline se puede solicitar que dicha funcin se compile como una funcin en lnea.
class nombre_clase { public: tipo nombre_funcion ( lista_parametros ); ... }; inline tipo nombre_funcion ( lista_parametros ) { < implementacin > }

Asignacin de objetos

Es posible asignar un objeto a otro, siempre y cuando sean del mismo tipo (es decir, pertenezcan a la misma clase). En este caso, la asignacin se hace dato miembro a dato miembro. Ejemplo:
int main() { Rectangulo l1( 5, 6 ); Rectangulo l2( 4, 5 ); l2 = l1; // Equivalente a l2.lado1 = l1.lado1 y l2.lado2 = l1.lado2 cout << l2.calcularArea() << endl; } // Visualiza 30

10 Paso de objetos a funciones

Por defecto (si no se indica nada) se pasan por valor (copia) . El objeto se copia en el parmetro de la funcin llamada, aunque sin utilizar el constructor normal (se utiliza un constructor especial). S se llama al destructor cuando la funcin que fue llamada termina.
tipo nombre_funcion ( clase1 obj1, clase2 obj2, ... ) { ... }

Ejemplo:
float sumar(empleado e1, empleado e2) { return ( e1.consultarSalario() + e2.consultarSalario() ); } int main() { Empleado pepe ( "12345678a" ); Empleado juan ( "87654321z ); pepe.calcularSalario ( 34 ); juan.calcularSalario ( 37 ); cout << "\nAmbos ganaron << sumar ( pepe, juan ) << endl; }

En realidad, existe una segunda posibilidad, que es mucho ms eficiente. Se trata del paso por referencia constante, de tal manera que el paso es por referencia, lo cual hace que sea mucho ms eficiente (no se realizan copias), pero no se permite modificar el objeto en la funcin llamada, con lo cul se obtiene lo mejor de ambos mundos.
float sumar(const empleado &e1, const empleado &e2) { return ( e1.consultarSalario() + e2.consultarSalario() ); } int main() {

Empleado pepe ( "12345678a" ); Empleado juan ( "87654321z ); pepe.calcularSalario ( 34 ); juan.calcularSalario ( 37 ); cout << "\nAmbos ganaron << sumar( pepe, juan ) << endl; }

11

Colecciones de objetos

Dado que un objeto es una variable, tambin es posible crear colecciones (vectores y matrices) de objetos. Sintaxis (con constructor por defecto):
clase array_objetos[ tamao ]; array_objetos[ indice ].funcion ( argumentos );

El problema bsico a la hora de crear una coleccin de objetos consiste en cmo inicializarlos, ya que probablemente se querra darles parmetros distintos a cada uno de ellos en su constructor, lo cual es en principio imposible. La primera forma de abordar este problema, es darle al objeto un constructor por defecto, de manera que la dificultad desaparece totalmente (como se aprecia un poco ms arriba). La segunda forma consiste en utilizar un formato especfico en la creacin de la coleccin, indicando individualmente, para cada elemento, qu parmetros se le pasan a su constructor (esto es slo viable dado un nmero reducido de elementos). En cuanto a esta ltima forma, existen dos formatos: el extendido y el reducido. El formato extendido consiste en poner el nombre de la clase, y a continuacin, entre parntesis, todos los parmetros de inicializacin que se deseen. El formato reducido slo se puede usar si el constructor tiene un solo argumento o todos sus parmetros son predeterminados excepto uno, el que se proporciona mediante el valor. Ntese que, con esta forma de crear los objetos, como parte de un vector o una matriz, los constructores de cada elemento son llamados inmediatamente despus de reservar el espacio necesario, as como los destructores son llamados justo antes de que la coleccin se elimine. Sintaxis (con constructor parametrizado)
// Reducida clase array_objetos [ tamao ] = { valor1, valor2, ...}; // Extendida clase array_objetos [ tamao ] = { clase( valor1 ), clase( valor2 ), ...};

Ejemplo
int main() { const unsigned int Tam = 3; Empleado empresa[ Tam ] = { Empleado( "11111111u", 0.1 ), Empleado( "22222222d", 0.11 ), Empleado( "33333333t", 0.12 ) };

for (int i = 0; i < Tam; i++) { empresa[ i ].calcular_salario( 30, Tam * ( i +1 ) ); cout << "\nEmpleado : << empresa[ i ].consultar_DNI(); cout << Salario semanal << empresa[ i ].consultar_salario(); } }

Otro ejemplo, en el que se asume que el constructor de empleado acepta todos sus parmetros por defecto excepto uno (el DNI), sera el siguiente, siguiendo el programa de arriba.
Empleado empresa[ tam ] = { "11111111u", "22222222d", "33333333t" };

12 La clase estndar string de C++

En el lenguaje de programacin C, las cadenas son vectores de caracteres (char[]), de manera que es necesario llamar a ciertas funciones de la librera estndar para poder manipularlas. El lenguaje de programacin C++ provee la clase string en su librera estndar, que automatiza de manera muy sencilla ciertas operaciones. Dado que es una clase, el uso bsico de string es el mismo que el de cualquier otra clase. Ntese que, para poder emplear la clase string, es necesario incluir la cabecera string. Sintaxis
string nombre_cadena;

En realidad, la clase string proporciona varios otras formas de crear cadenas, ya que tiene una capacidad de construccin muy rica. Ejemplos:
#include <iostream> #include <string> using namespace std; int main() { string s1(PRO II); string s2 = Adis; string s3( 4,* ); s2 = Hola, holita; cout << s2 << s3 << s1 << endl; }

Ejemplos con errores:

string string string string s1 = y; s2 = 5; s3 = (y); s4(3);

En una sentencia de asignacin s se le puede asignar (o aadir) un solo carcter.

Ejemplo:
int main() { string s1; s1 = n; s1 += o; cout << s1 << endl; }

12.1 Lectura de una cadena en C++

La forma estndar de leer una cadena de consola en C++ es mediante el operador de extraccin (>>). Sin embargo, hay que tener en cuenta que el espacio en blanco se entiende como un delimitador por esta forma de entrada. Ejemplo
int main() { string nombre; string direccion; cout << Introduzca su nombre: ; cin >> nombre; cout << Introduzca su direccin: ; cin >> direccion; cout << Nombre: << nombre << endl << Direccin: << direccion << endl; }

Tal y como se ha indicado, el carcter espacio es un delimitador, as que si en la primera lectura, cuando se solicita el nombre, se introduce Baltasar Garca, la cadena nombre tendr el valor Baltasar, y la cadena direccion contendr Garca. Adems, el usuario se encontrar con que el programa se salta la introduccin de la direccin, visualizando finalmente: Nombre: Baltasar Direccin: Garca. La forma ms sencilla de evitar esto es emplear la funcin getline. El primer parmetro es un flujo de entrada (como cin), el segundo un objeto string y el tercero (opcional) el carcter con el que se delimita el final de la entrada. Ejemplo
string s1; getline( cin, s1 ); getline( cin, s1, x ); int main() { string nombre; string direccion;

cout << Introduzca su nombre: ; getline( cin, nombre ); cout << Introduzca su direccin: ; getline( cin, direccion ); cout << Nombre: << nombre << endl << Direccin: << direccion << endl; }

El acceso a caracteres individuales se realiza mediante el operador [], sin verificacin del intervalo. Ejemplo
int main() { string s1( hola ); cout << Primera letra : << s1[ 0 ] << endl; cout << Introduce la nueva letra: ; cin << s1[ 0 ]; cout << s1; }

Ntese que existe la funcin miembro at(), que realiza la misma operacin que el operador []. En caso de que el carcter pedido no se encuentre dentro del intervalor correcto de la cadena (desde 0, hasta la longitud de la cadena menos uno, ambos inclusive), el programa se detiene completamente con un error. Ejemplo
int main() { string s1( prueba ); cout << s1.at( 2 ); s1.at( 2 ) = x; cout << s1.at( 22 ) << endl; }

// ERROR

12.2 Funciones miembro

La funcin miembro length() devuelve la longitud de la cadena. Ejemplo
cout << "Longitud de la cadena es: " << s1.length();

La funcin miembro assign() permite cambiar el contenido de la cadena por el parmetro que se le pase. Ejemplo
int main() {

string s1 ( hola ); string s2; s2.assign ( s1 ); s2.assign ( s1, 1, 3 ); } // s2 es hola // s2 es ola

La funcin miembro append(), al igual que el operador +=, permiten aadir una cadena a otra ya existente. El operador + complementa los anteriores para concatenar dos cadenas sin modificar ninguna de ellas, devolviendo una de ellas. Ejemplo
int main() { string string string string string

cad; s1( Esto ); s2( es la ); s3( prueba ); s4( final );

cad = s1 + s2; cad.append( s3 ); cout << Concatenacin: << cad << endl; }

La funcin miembro compare(), acepta una cadena como parmetro, comparando sta con la del objeto. Devuelve un valor positivo si la cadena del objeto se situara en orden alfabtico despus de la cadena pasada como parmetro; un valor negativo en el caso contrario; y, finalmente, un cero, cuando ambas cadenas son iguales. Tambin es posible utilizar los operadores lgicos equivalentes ( ==, !=, >, <, >=, <= ). Ejemplo
int main() { string s1; string s2; getline( cin, s1 ); getline( cin, s2 ); if ( s1 == s2 ) { cout << Son iguales << endl; } else { if ( s1 > s2 ) { cout << "S1 va despus que S2" << endl; } else { cout << "S2 va despus que S1" << endl; } } return EXIT_SUCCESS; }

Este ejemplo es equivalente a:

int main() { string s1; string s2; getline( cin, s1 ); getline( cin, s2 ); if ( s1.compare( s2 ) == 0 ) { cout << Son iguales << endl; } else { if ( s1.compare( s2 ) > 0 ) { cout << "S1 va despus que S2" << endl; } else { cout << "S2 va despus que S1" << endl; } } return EXIT_SUCCESS; }

La funcin miembro substr() devuelve una subcadena, pasndole como argumentos la primera posicin, y el nmero de caracteres. Ejemplo
int main() { string s1( hola ); cout << "Dos primeros caracteres: << s1.substr( 0, 2 ); }

La funcin miembro swap() intercambia los caracteres entre una cadena y otra. Ejemplo
int main() { string s1( hola ) string s2( adios ); s1.swap ( s2 ); cout << s1 << y s2 << endl } // adios y hola