2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 6: Clases y Abstracción de Datos Índice...

2003 Prentice Hall, Inc. All rights reserved.

1

Capítulo 6: Clases yAbstracción de Datos

Índice del capítulo6.1 Introducción6.2 Estructuras6.3 Clases6.4 Ámbito de Clase y Acceso a Miembros de Clase6.5 Separación de Interfaz e Implementación6.6 Funciones de Acceso y de Utilidad6.7 Inicialización de Objetos y Uso de Argumentos Predeterminados mediante Constructores6.8 Uso de Funciones Set y Get6.9 Asignación Predeterminada a Nivel de Miembro


2

6.1 Introducción

• Programación orientada a objetos (POO) – Encapsula los datos (atributos) y las funciones

(comportamiento) en paquetes llamados clases

• Ocultamiento de información – Los objetos de una clase se comunican a través de interfaces

bien definidas, pero– los detalles de implementación están ocultos dentro de las

propias clases

• CLASES: Tipos definidos por el usuario (o tipos definidos por el programador)– Datos (datos miembro) – Funciones (funciones miembro o métodos)– Instancia de una clase: objeto


3

6.2 Estructuras• Estructuras

– Tipos de datos agregados que se construyen empleando elementos de otros tipos

struct Time {

int hora; //0-23

int minuto; //0-59

int segundo; //0-59

};

• Nombres de los miembros de la estructura:– En la misma struct: deben tener nombres únicos

– En diferentes structs: pueden compartir nombre

• La definición de struct debe finalizar en ;

Etiqueta de la estructura

Miembros de la estructura


4

6.2 Estructuras

• Estructuras autorreferenciadas: – Una estructura no puede ser una instancia de sí misma, pero– el miembro de una estructura puede ser un puntero a una instancia

de la misma estructura (estructura autorreferenciada)• Usado para listas enlazadas, colas, pilas y árboles

• La definición de struct– Crea un nuevo tipo de datos que se utiliza para declarar variables– Las variables estructura se declaran como las variables de otros

tipos– Ejemplos:

• Time timeObjeto;• Time timeArray[ 10 ]; • Time *timePtr;• Time &timeRef = timeObjeto;


5

6.2 Estructuras

• Operadores de acceso a miembros de estructura:– Operador punto (.) accede a un miembro de estructura o clase

a través del nombre de variable del objeto.

– Operador flecha (->) accede a un miembro de estructura o clase por medio de un puntero al objeto

– Imprimo miembro hora de timeObjeto:

cout << timeObjeto.hora; O

timePtr = &timeObjeto; cout << timePtr->hora;

– timePtr->hora es lo mismo que (*timePtr).hora• Los paréntesis son obligatorios, pues * tiene menor precedencia

que .


6

6.2 Estructuras

• Por defecto: las estructuras se pasan como una llamada por valor– Pasar la estructura por referencia:

• Evita la sobrecarga de la copia de la estructura

• Estructuras estilo C– No hay “interfaz” con la estructura

• Si la implementación cambia, todos los programas que usan esa estructura deben modificarse. Esto es porque el programador manipula directamente el tipo de datos.

– No se pueden imprimir como una unidad• Hay que imprimir y dar formato a sus miembros uno a la vez

– No se pueden comparar en su totalidad• Deben compararse miembro a miembro

2003 Prentice Hall, Inc.All rights reserved.

Outline7

1 // Fig. 6.1: fig06_01.cpp2 // Crea una estructura, da valores a sus miembros, y la imprime.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setfill;11 using std::setw;12 13 // definición de estructura 14 struct Time { 15 int hora; // 0-23 (formato 24-horas)16 int minuto; // 0-59 17 int segundo; // 0-59 18 19 }; // fin de la estructura Time 20 21 void imprimeUniversal( const Time & ); // prototipo22 void imprimeEstandar( const Time & ); // prototipo23

Define el tipo estructura Time con 3 miembros enteros.

Pasa referencias a objetos constantes tipo Time para eliminar la sobrecarga de la copia.

fig06_01.cpp(1 de 3)


Outline8

24 int main()25 {26 Time horaCena; // variable del nuevo tipo Time 27 28 horaCena.hora = 18;29 horaCena.minuto = 30;30 horaCena.segundo = 0;31 32 cout << "La cena tendrá lugar a las ";33 imprimeUniversal( horaCena );34 cout << " hora universal,\nque son las ";35 imprimeEstandar( horaCena ); 36 cout << " hora estándar.\n";37 38 horaCena.hora = 29; // valor de hora no válido 39 horaCena.minuto = 73; // valor de minuto no válido40 41 cout << "\nHora con valores incorrectos: ";42 imprimeUniversal( horaCena );43 cout << endl;44 45 return 0; 46 47 } // fin de main48

Usa operador punto para inicializar los miembros de la estructura.

El acceso directo a los datos permite la asignación de valores incorrectos.



Outline9

49 // imprime la hora en formato universal50 void imprimeUniversal( const Time &t )51 {52 cout << setfill( '0' ) << setw( 2 ) << t.hora << ":"53 << setw( 2 ) << t.minuto << ":" 54 << setw( 2 ) << t.segundo;55 56 } // fin de la función imprimeUniversal57 58 // imprime la hora en formato estándar59 void imprimeEstandar( const Time &t )60 {61 cout << ( ( t.hora == 0 || t.hora == 12 ) ? 62 12 : t.hora % 12 ) << ":" << setfill( '0' )63 << setw( 2 ) << t.minuto << ":" 64 << setw( 2 ) << t.segundo 65 << ( t.hora < 12 ? " AM" : " PM" );66 67 } // fin de función imprimeEstandar

La cena tendrá lugar a las 18:30:00 hora universal,

que son las 6:30:00 PM hora estándar.

Hora con valores incorrectos: 29:73:00

Manipulador de flujo con parámetros setfill.

Operador punto para acceder a los datos miembro.


fig06_01.cppsalida


10

6.3 Clases

• Permiten que el programador modele objetos con:– Atributos (datos miembro)

– Comportamientos (funciones miembro)

• Se definen mediante la palabra clave class• Funciones miembro

– Llamadas métodos en algunos lenguajes

– Se invocan en respuesta a mensajes enviados a un objeto.


11

6.3 Clases• Especificadores de acceso a miembros

– public: • Accesible por cualquier función del programa que manipule un

objeto de la clase

• Propósito: interfaz public de la clase

– private:• Modo de acceso por defecto para los miembros de la clase

• Accesible sólo para las funciones miembro de la clase

• Acceso controlado por las funciones de acceso (métodos de acceso)

– Función get (lee datos private)– Función set (modifica datos private)


12

6.3 Clases

• Función constructor de la clase:– Función miembro especial que:

• Inicializa los datos miembros de un objeto de clase

• Tiene el mismo nombre que la clase

– No devuelve ningún valor

– Se invoca automáticamente cuando se crea un objeto de tal clase

• Función destructor de la clase:– Mismo nombre que la clase, pero precedido con tilde (~)

– No recibe argumentos ni devuelve ningún valor

– Realiza “tareas de terminación” antes de que el sistema recupere la memoria del objeto, para que ésta pueda ser reutilizada y contenga objetos nuevos.

– Si no existe destructor explícito, el compilador crea uno “vacío”


13

6.3 Clases

• Constructores y destructores– Llamados implícitamente por el compilador

• Orden de llamadas a estas funciones– Depende del orden en que la ejecución entre y salga del ámbito

en que se instancian los objetos

– Por lo general, las llamadas a destructores se efectúan en el orden inverso a las llamadas a constructores


Outline14

1 class Time {2 3 public:4 Time();5 void setTime( int, int, int );6 void imprimeUniversal();7 void imprimeEstandar();8 9 private:10 int hora; // 0 - 23 (formato reloj en 24-horas)11 int minuto; // 0 - 5912 int segundo; // 0 - 5913 14 }; // fin de la clase Time

La definición de clase comienza con la palabra clave class.

El cuerpo de la clase comienza con llave izquierda.

El cuerpo de la clase finaliza con llave derecha.

La definición finaliza con punto y coma.

Prototipos de funciones para funciones miembro public.

Datos miembro private accesibles sólo por funciones miembro.

Constructor: mismo nombre que clase, Time, y no tipo de devolución.

Líneas 3 y 9: Especificadores public y private de acceso a miembros de la clase.


15

6.3 Clases

• Objetos de una clase– Después de la definición de la clase,

• el nombre de la clase se vuelve un nuevo especificador de tipo

– C++ es un lenguaje extensible, pues el programador puede ir creando, según vaya necesitando, nuevos tipos de clase.

• Se puede usar como especificador de tipo para objetos, arrays, punteros y referencias

– Ejemplo:

Time ocaso; // objeto de tipo TimeTime arrayDeHoras[ 5 ]; // array de objetos TimeTime *punteroAHora; // puntero a objeto TimeTime &horaCena = ocaso; // referencia a objeto Time

El nombre de la clase se vuelve un nuevo especificador de tipo.


16

6.3 Clases

• Funciones miembro definidas fuera de la clase– Operador binario de resolución de ámbito (::)

• “Enlaza” nombre de miembro con nombre de clase• Identifica unívocamente las funciones de una clase en particular• Clases diferentes pueden tener funciones miembro con el mismo nombre

– Formato para definir funciones miembroValorDevuelto NombreClase::NombreFuncionMiembro( ){…

}– No cambia si la función es public o private

• Funciones miembro definidas dentro de la clase– No necesitan operador de resolución de ámbito ni nombre de clase– El compilador las trata como funciones inline

• Fuera de la clase, se podrían tratar como funciones inline añadiendo explícitamente la palabra clave inline


Outline17

1 // Fig. 6.3: fig06_03.cpp2 // Clase Time.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setfill;11 using std::setw;12 13 // Definición del tipo abstracto de datos (TAD) Time14 class Time { 15 16 public: 17 Time(); // constructor 18 void setTime( int, int, int ); // fija hora, minuto, segundo 19 void imprimeUniversal(); // imprime hora en formato universal20 void imprimeEstandar(); // imprime hora en formato estándar 21 22 private: 23 int hora; // 0 - 23 (formato de reloj de 24-horas) 24 int minuto; // 0 - 59 25 int segundo; // 0 - 59 26 27 }; // fin de clase Time 28

Define clase Time.



Outline18

29 // El constructor Time inicializa cada dato miembro a cero y30 // asegura que todos los objetos Time comiencen en un estado consistente31 Time::Time() 32 { 33 hora = minuto = segundo = 0; 34 } // fin del constructor Time35 36 // escribe nuevo valor de Time usando hora universal,37 // valida los datos y pone valores incorrectos a cero38 void Time::setTime( int h, int m, int s ) 39 { 40 hora = ( h >= 0 && h < 24 ) ? h : 0; 41 minuto = ( m >= 0 && m < 60 ) ? m : 0; 42 segundo = ( s >= 0 && s < 60 ) ? s : 0; 43 } // fin de la función setTime 44 45 // imprime hora en formato universal46 void Time::imprimeUniversal()47 {48 cout << setfill( '0' ) << setw( 2 ) << hora << ":"49 << setw( 2 ) << minuto << ":" << setw( 2 ) << segundo;50 } // fin de función imprimeUniversal51 52 // imprime hora en formato estándar53 void Time::imprimeEstandar()54 {55 cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 )56 << ":" << setfill( '0' ) << setw( 2 ) << minuto57 << ":" << setw( 2 ) << segundo << ( hora < 12 ? " AM" : " PM" );58 } // fin de función imprimeEstandar59

El constructor inicializa los datos miembros private a 0.

Función miembro public comprueba la validez de los valores de los parámetros antes de fijar los datos miembro private.

No argumentos (“conoce” implícitamente que el propósito es imprimir funciones miembro); la llamada a la función miembro es así más concisa.



Outline19

60 int main()61 {62 Time t; // instancia objeto t de la clase Time63 64 // imprime valores iniciales del objeto Time t65 cout << "La hora universal inicial es ";66 t.imprimeUniversal(); // 00:00:0067 cout << "\nLa hora estándar inicial es ";68 t.imprimeEstandar(); // 12:00:00 AM69 70 t.setTime( 13, 27, 6 ); // cambia la hora71 // imprime los nuevos valores del objeto Time t72 cout << "\n\nLa hora universal después de setTime es ";73 t.imprimeUniversal(); // 13:27:0674 cout << "\nLa hora estándar después de setTime es ";75 t.imprimeEstandar(); // 1:27:06 PM76 77 t.setTime( 99, 99, 99 ); // intenta escribir hora no válida78 // imprime los valores de t después de especificar valores no válidos79 cout << "\n\nDespués de intentar dar valores no válidos:"80 << "\nHora universal: ";81 t.imprimeUniversal(); // 00:00:0082 cout << "\nHora estándar: ";83 t.imprimeEstandar(); // 12:00:00 AM84 cout << endl;85 return 0; 86 }

Invoca funciones miembro public para imprimir la hora.

Da valores a los datos miembro usando función miembro public.

Intenta dar valores no válidos a los datos miembro usando función miembro public.

Declara variable t como un objeto de la clase Time.

Los datos miembro se fijan a 0 después de intentar darles valores no válidos.



Outline20

La hora universal inicial es 00:00:00

La hora estándar inicial es 12:00:00 AM

La hora universal después de escribeHora es 13:27:06

La hora estándar después de escribeHora es 1:27:06 PM

Después de intentar dar valores no válidos:

Hora universal: 00:00:00

Hora estándar: 12:00:00 AM

fig06_03.cppsalida


21

6.4 Ámbito de Clase y Acceso a los Miembros de una Clase

• Ámbito de clase – Datos miembro, funciones miembro– Dentro del ámbito de clase

• Los datos miembro de una clase:– son accesibles de forma inmediata por todas las funciones

miembro de esa clase– pueden ser referenciados por su nombre

– Fuera del ámbito de clase• Los miembros se referencian a través de uno de los

controladores de un objeto:– un nombre de objeto, una referencia a objeto o un puntero

a objeto

• Ámbito de fichero – Funciones no miembro


22


• Ámbito de función– Variables definidas en la función miembro

– Sólo conocidas por esa función

– Si variables con mismo nombre que variable con ámbito de clase:

• Se “oculta” la variable con ámbito de clase

– Pero se puede acceder a ella usando el operador de resolución de ámbito (::)

NombreClase::nombreVariableClase

– Las variables se destruyen al finalizar la ejecución de la función


23


• Operadores para acceder a los miembros de una clase– Los mismos que para las estructuras

– Operador punto de selección de miembros (.)• Se combina con:

– objeto, referencia a objeto

para acceder a los miembros del objeto

– Operador flecha de selección de miembros (->) • Se combina con:

– Puntero a objeto

para acceder a los miembros del objeto


Outline24

1 // Fig. 6.4: fig06_04.cpp2 // Demostración de los operadores de acceso a miembros de clase . y ->3 //4 // PRECAUCIÓN: EN LOS EJEMPLOS POSTERIORES EVITAREMOS LOS DATOS PÚBLICOS5 #include <iostream>6 7 using std::cout;8 using std::endl;9 10 // definición de clase Cuenta11 class Cuenta {12 public:13 int x;14 void imprime() 15 { 16 cout << x << endl; 17 }18 }; // fin de clase Cuenta19

El dato miembro x es public para ilustrar los operadores de acceso a los miembros de una clase; pero normalmente los datos miembro son private.



Outline25

20 int main()21 {22 Cuenta contador; // crea objeto contador23 Cuenta *contadorPtr = &contador; // crea puntero a contador 24 Cuenta &contadorRef = contador; // crea referencia a contador25 26 cout << "Asigna 1 a x y lo imprime usando el nombre del objeto: ";27 contador.x = 1; // asigna 1 al dato miembro x 28 contador.imprime(); // llama a la función miembro imprime29 30 cout << "Asigna 2 a x y lo imprime usando una referencia: ";31 contadorRef.x = 2; // asigna 2 al dato miembro x 32 contadorRef.imprime(); // llama a la función miembro imprime33 34 cout << "Asigna 3 a x y lo imprime usando un puntero: ";35 contadorPtr->x = 3; // asigna 3 al dato miembro x 36 contadorPtr->imprime(); // llama a la función miembro imprime37 38 return 0; 39 40 }

Asigna 1 a x y lo imprime usando el nombre del objeto: 1

Asigna 2 a x y lo imprime usando una referencia: 2

Asigna 3 a x y lo imprime usando un puntero: 3

Usa operador punto de selección de miembro para el objeto contador.

Usa operador punto de selección de miembro para la referencia a objeto contadorRef.

Usa operador flecha de selección de miembro para el puntero a objeto contadorPtr.


fig06_04.cppsalida


26

6.5 Separación de Interfaz e Implementación

• Separación de interfaz e implementación en distintos ficheros– Ventaja:

• Hace más fácil la modificación de programas: Los cambios en la implementación de una clase no afectan al programa que las usa, siempre que no cambie la interfaz.

– Desventaja:• Archivos de encabezado

– Contienen alguna parte de la implementación

• Funciones miembro inline

– Sugerencias sobre otras partes de la implementación

• Miembros private


27

6.5 Separación de Interfaz e Implementación

• Ficheros de encabezado– Definiciones de clases y prototipos de funciones

– Se incluye en todos los archivos que utilicen la clase• #include

– Extensión de fichero .h

• Ficheros con código fuente– Definición de funciones miembro

– Convención: Códigos fuente con mismo nombre base

– Se compila y se enlaza con el archivo que contiene el programa principal


Outline28

1 // Fig. 6.5: time1.h 2 // Declaración de la clase Time. 3 // Las funciones miembro están definidas en time1.cpp4 5 // Previene múltiples inclusiones del fichero de encabezado6 #ifndef TIME1_H7 #define TIME1_H8 9 // Definición del tipo abstracto de datos Time10 class Time {11 12 public:13 Time(); // constructor14 void setTime( int, int, int ); // fija hora, minuto, segundo15 void printUniversal(); // imprime hora en formato universal16 void printStandard(); // imprime hora en formato estándar17 18 private:19 int hora; // 0 - 23 (formato de reloj de 24-horas)20 int minuto; // 0 - 5921 int segundo; // 0 - 5922 23 }; // fin de la clase Time24 25 #endif El código entre las directivas #ifndef y #endif no se

incluye si el nombre TIME1_H ya está definido.

“Si no está definido”

La directiva del procesador define el nombre TIME1_H.

Convención de nombre: nombre de fichero de encabezado con subrayado sustituyendo al punto.

time1.h


Outline29

time1.cpp(1 de 2)

1 // Fig. 6.6: time1.cpp2 // Definición de funciones miembro para la clase Time.3 #include <iostream>4 #include <iomanip>5 using std::cout;6 using std::setfill;7 using std::setw;8 // incluye definición de clase Time en time1.h9 #include "time1.h" 10 11 // El constructor Time inicializa cada dato miembro a cero.12 // Asegura que todos los objetos Time se inicien en estado consistente.13 Time::Time() 14 { 15 hora = minuto = segundo = 0; 16 } // fin de constructor Time1718 // Escribe nuevo valor de Time usando hora universal. Comprueba la19 // validez de los datos. Fija los datos no válidos a cero.20 void Time::setTime( int h, int m, int s )21 {22 hora = ( h >= 0 && h < 24 ) ? h : 0;23 minuto = ( m >= 0 && m < 60 ) ? m : 0;24 segundo = ( s >= 0 && s < 60 ) ? s : 0;25 } // fin de función setTime26

Incluye el fichero de encabezado time1.h.

Nombre del fichero de encabezado entre comillas; ponerlo entre ángulos causa que el preprocesador asuma que el encabezado es parte de la Biblioteca Estándar de C++.


Outline30

time1.cpp(2 de 2)

27 // imprime Time en formato universal28 void Time::imprimeUniversal()29 {30 cout << setfill( '0' ) << setw( 2 ) << hora << ":"31 << setw( 2 ) << minuto << ":"32 << setw( 2 ) << segundo;33 } // fin de la función imprimeUniversal34 35 // imprime Time en formato estándar36 void Time::imprimeEstandar()37 {38 cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 )39 << ":" << setfill( '0' ) << setw( 2 ) << minuto40 << ":" << setw( 2 ) << segundo 41 << ( hora < 12 ? " AM" : " PM" );42 } // fin de función imprimeEstandar


Outline31


1 // Fig. 6.7: fig06_07.cpp2 // Programa para comprobar la clase Time. 3 // NOTA: Este fichero debe compilarse con time1.cpp.4 #include <iostream>5 using std::cout;6 using std::endl;7 // incluye definición de clase Time en time1.h8 #include "time1.h" 9 10 int main()11 {12 Time t; // instancia el objeto t de la clase Time13 14 // imprime valores iniciales del objeto Time t15 cout << "La hora universal inicial es ";16 t.imprimeUniversal(); // 00:00:0017 cout << "\nLa hora estándar inicial es ";18 t.imprimeEstandar(); // 12:00:00 AM19 20 t.setTime( 13, 27, 6 ); // cambio la hora21 // imprimo los nuevos valores del objeto Time t22 cout << "\n\nLa hora universal después de setTime es ";23 t.imprimeUniversal(); // 13:27:0624 cout << "\nLa hora estándar después de setTime es ";25 t.imprimeEstandar(); // 1:27:06 PM26

Incluye fichero de encabezado time1.h para asegurar una correcta creación/manipulación y determinar el tamaño del objeto de la clase Time.


Outline32


fig06_07.cppsalida

27 t.setTime( 99, 99, 99 ); // intenta valores no válidos28 29 // imprimo valores de t después de especificar valores no válidos30 cout << "\n\nDespués de intentar establecer valores no válidos:"31 << "\nHora universal: ";32 t.imprimeUniversal(); // 00:00:0033 cout << "\nHora estándar: ";34 t.imprimeStandard(); // 12:00:00 AM35 cout << endl;36 37 return 0; 38 }

La hora universal inicial es 00:00:00

La hora estándar inicial es 12:00:00 AM

La hora universal después de setTime es 13:27:06

La hora estándar después de setTime es 1:27:06 PM

Después de intentar establecer valores no válidos:

Hora universal: 00:00:00

Hora estándar: 12:00:00 AM

Compilación: co fig06_07 time1 g++ -o fig06_07.exe fig06_07.cpp time1.cpp


33

6.6 Funciones de acceso y de utilidades

• Funciones de acceso– public

– Leen/visualizan datos

– Funciones de predicado• Chequean condiciones verdadera/falsa

• Funciones de utilidades (funciones de ayuda)– private– Dan apoyo a la operación de las funciones miembro public de la clase

– No están hechas para que los clientes de una clase las utilicen directamente


Outline34

salesp.h

1 // Fig. 6.9: salesp.h2 // Definición de clase SalesPerson.3 // Funciones miembro definidas en salesp.cpp.4 #ifndef SALESP_H5 #define SALESP_H6 7 class SalesPerson {8 9 public:10 SalesPerson(); // constructor11 void getSalesFromUser(); // obtiene ventas del teclado12 void setSales( int, double ); // fija ventas de un mes13 void printAnnualSales(); // suma e imprime ventas14 15 private: 16 double totalAnnualSales(); // función de utilidad17 double sales[ 12 ]; // ventas de 12 meses18 19 }; // fin de la clase SalesPerson20 21 #endif

Función de acceso set realiza validación de datos.

Función de utilidad private.


Outline35

salesp.cpp(1 de 2)

1 // Fig. 6.10: salesp.cpp2 // Funciones miembro de la clase SalesPerson.3 #include <iostream>4 #include <iomanip>5 using std::cout;6 using std::cin;7 using std::endl;8 using std::fixed;9 using std::setprecision;10 // incluye la definición de la clase SalesPerson en salesp.h11 #include "salesp.h"12 13 // inicializa elementos del array de ventas sales a 0.014 SalesPerson::SalesPerson()15 {16 for ( int i = 0; i < 12; i++ )17 sales[ i ] = 0.0;18 } // fin del constructor SalesPerson1920 // Obtiene 12 cifras de ventas del usuario por teclado21 void SalesPerson::getSalesFromUser()22 {23 double salesFigure; 24 for ( int i = 1; i <= 12; i++ ) {25 cout << "Introduzca las ventas del mes " << i << ": ";26 cin >> salesFigure;27 setSales( i, salesFigure );28 } // fin de for29 } // fin de función getSalesFromUser30


Outline36

salesp.cpp(2 de 2)

31 // Función para fijar una de las 12 cifras de ventas mensuales; la función32 // resta 1 del valor del mes para obtener un índice correcto en array sales33 void SalesPerson::setSales( int mes, double cantidad )34 {35 // comprueba mes y cantidad con valores correctos36 if ( mes >= 1 && mes <= 12 && cantidad > 0 )37 sales[ mes - 1 ] = cantidad; // ajuste para índices 0-1138 else // mes o ventas no válidas39 cout << "Mes o cifra de ventas no válidos" << endl; 40 } // fin de función setSales41 42 // imprime el total de las ventas del año (con ayuda de función de utilidad)

43 void SalesPerson::printAnnualSales()44 {45 cout << setprecision( 2 ) << setiosflags(ios::fixed)46 << "\nEl total anual de ventas es: $" 47 << totalAnnualSales() << endl; // llamo a función de utilidad48 } // fin de función printAnnualSales49 50 // Función de utilidad private para calcular el total de ventas51 double SalesPerson::totalAnnualSales() 52 { 53 double total = 0.0; // inicializa total54 for ( int i = 0; i < 12; i++ ) // suma ventas de 12 meses55 total += sales[ i ]; 69 return total;71 } // fin de función totalAnnualSales

Función de acceso set realiza chequeo de validez.

Función de utilidad private para ayudar a la función printAnnualSales; encapsula la lógica de manipulación del array sales.


Outline37

fig06_11.cpp

fig06_11.cppsalida

1 // Fig. 6.11: fig06_11.cpp2 // Demostración de la función utilidad.3 // Compila este programa con salesp.cpp4 // incluye la definición de la clase SalesPerson de salesp.h5 #include "salesp.h" 6 7 int main()8 {9 SalesPerson s; // crea un objeto SalesPerson s10 s.getSalesFromUser(); // código secuencial simple; no11 s.printAnnualSales(); // estructuras de control en main12 return 0;13 }

Introduzca las ventas del mes 1: 5314.76












El total anual de ventas es: $60120.59

Secuencia simple de llamadas a funciones miembro; lógica encapsulada en funciones miembro.


38

6.7 Inicialización de Objetos y Uso de Argumentos Predeterminados

• Inicialización de datos miembro:– Pasando los valores iniciales como argumentos al constructor

• Entre paréntesis a la derecha del nombre del objeto y antes del punto y coma

NombreClase NombreObjeto( valor1,valor2,…);

– O pueden establecerse sus valores más adelante, después de la creación del objeto.

• Argumentos predeterminados (valores por defecto)– Constructor predeterminado

• Constructor que tenga valores predeterminados para todos sus argumentos (o que explícitamente no requiera argumentos)

• Puede ser llamado sin argumentos

• Sólo puede haber un constructor predeterminado por clase


Outline39

time2.h

1 // Fig. 6.12: time2.h2 // Declaración de la clase Time.3 // Funciones miembro definidas en time2.cpp.4 5 // previene múltiples inclusiones del fichero de encabezado6 #ifndef TIME2_H7 #define TIME2_H8 9 // Definición de tipo abstracto de datos Time10 class Time {11 12 public:13 Time( int = 0, int = 0, int = 0);// constructor predeterminado14 void setTime( int, int, int ); // fija hora, minuto, segundo15 void imprimeUniversal(); // imprime hora en formato universal16 void imprimeEstandar(); // imprime hora en formato estándar17 18 private:19 int hora; // 0 - 23 (formato de reloj de 24 horas)20 int minuto; // 0 - 5921 int segundo; // 0 - 5922 23 }; // fin de la clase Time24 25 #endif

Constructor predeterminado que especifica todos los argumentos.


Outline40

time2.cpp(1 de 2)

1 // Fig. 6.13: time2.cpp2 // Definición de funciones miembro para la clase Time.3 #include <iostream>4 #include <iomanip>5 using std::cout;6 using std::setfill;7 using std::setw;8 // incluye definición de clase Time en time2.h9 #include "time2.h" 10 11 // Constructor Time inicializa cada dato miembro a cero;12 // asegura que todos los objeto Time comienzan en un estado consistente13 Time::Time( int hr, int min, int seg ) 14 { 15 setTime( hr, min, seg ); // valida y fija hora16 } // fin del constructor Time17 18 // fija un nuevo valor de Time usando hora universal, realiza chequeo de19 // validez sobre los valores de los datos y fija valores no válidos a cero20 void Time::setTime( int h, int m, int s )21 {22 hora = ( h >= 0 && h < 24 ) ? h : 0;23 minuto = ( m >= 0 && m < 60 ) ? m : 0;24 segundo = ( s >= 0 && s < 60 ) ? s : 0;25 } // fin de la función setTime26

El constructor llama a setTime para validar los valores pasados (o predeterminados).


Outline41

time2.cpp(2 de 2)

27 // imprime Time en formato universal28 void Time::imprimeUniversal()29 {30 cout << setfill( '0' ) << setw( 2 ) << hora << ":"31 << setw( 2 ) << minuto << ":"32 << setw( 2 ) << segundo;33 } // fin de función imprimeUniversal34 35 // imprime Time en formato estándar36 void Time::imprimeEstandar()37 {38 cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 )39 << ":" << setfill( '0' ) << setw( 2 ) << minuto40 << ":" << setw( 2 ) << segundo 41 << ( hora < 12 ? " AM" : " PM" );42 } // fin de función imprimeEstandar


Outline42

fig06_14.cpp (1 de 2)

1 // Fig. 6.14: fig06_14.cpp 2 // Demostración de un constructor predeterminado para la clase Time.3 #include <iostream>4 using std::cout;5 using std::endl;6 // incluye definición de la clase Time de time2.h7 #include "time2.h"8 9 int main()10 {11 Time t1; // todos los argumentos por defecto12 Time t2( 2 ); // minuto y segundo por defecto13 Time t3( 21, 34 ); // segundo por defecto14 Time t4( 12, 25, 42 ); // especificamos todos los valores15 Time t5( 27, 74, 99 ); // especificamos todos los valores incorrectos16 17 cout << "Construido con:\n\n"18 << "Todos los argumentos predeterminados:\n ";19 t1.imprimeUniversal(); // 00:00:0020 cout << "\n ";21 t1.imprimeEstandar(); // 12:00:00 AM22

Inicialización de objetos Time usando argumentos predeterminados.

Inicialización de objeto Time con valores no válidos; el chequeo de su validez fijarán los valores a 0.


Outline43

fig06_14.cpp (2 de 2)

23 cout << "\n\nSe especifica hora; minutos y segundos predeterminados:\n ";24 t2.imprimeUniversal(); // 02:00:0025 cout << "\n ";26 t2.imprimeEstandar(); // 2:00:00 AM27 28 cout << "\n\nSe especifican hora y minutos; segundos predeterminados:\n "; 29 t3.imprimeUniversal(); // 21:34:0030 cout << "\n ";31 t3.imprimeEstandar(); // 9:34:00 PM32 33 cout << "\n\nSe especifican hora, minutos y segundos:\n ";34 t4.imprimeUniversal(); // 12:25:4235 cout << "\n ";36 t4.imprimeEstandar(); // 12:25:42 PM37 38 cout << "\n\nSe especifican todos a valores no válidos:\n ";39 t5.imprimeUniversal(); // 00:00:00 40 cout << "\n "; 41 t5.imprimeEstandar(); // 12:00:00 AM 42 cout << endl;43 44 return 0;45 } // fin de main

t5 construido con argumentos no válidos; sus valores si fijan a 0.


Outline44

fig06_14.cpp salida

Construido con:

Todos los argumentos predeterminados:

00:00:00

12:00:00 AM

Se especifica hora; minutos y segundos predeterminados:

02:00:00

2:00:00 AM

Se especifican hora y minutos; segundos predeterminados:

21:34:00

9:34:00 PM

Se especifican hora, minutos y segundos:

12:25:42

12:25:42 PM

Se especifican todos a valores no válidos:

00:00:00

12:00:00 AM


45

6.8 Uso de Funciones Set y Get

• Funciones Set– Realizan comprobación de validez de los datos antes de

modificar los datos private– Notifican al cliente de la clase si se intenta asignar valores

no válidos a un dato miembro.• Lo indican devolviendo algún valor con ese significado

• Funciones Get– Funciones “de consulta”

– Controla el formato de los datos devueltos


Outline46

time3.h

1 // Fig. 6.18: time3.h2 // Declaración de clase Time.3 // Funciones miembro definidas en time3.cpp4 // previene múltiples inclusiones del fichero de cabecera5 #ifndef TIME3_H 6 #define TIME3_H 7 8 class Time {9 public:10 Time( int = 0, int = 0, int = 0 ); // constructor predeterminado11 // funciones set12 void setTime( int, int, int ); // fija hora, minuto, segundo13 void setHora( int ); // fija hora 14 void setMinuto( int ); // fija minuto15 void setSegundo( int ); // fija segundo16 // funciones get17 int getHora(); // devuelve hora 18 int getMinuto(); // devuelve minuto19 int getSegundo(); // devuelve segundo20 void imprimeUniversal(); // imprime hora en formato universal21 void imprimeEstandar(); // imprime hora en formato estándar22 private:23 int hora; // 0 - 23 (formato de reloj de 24 horas)24 int minuto; // 0 - 5925 int segundo; // 0 - 5926 }; // end clas Time27 #endif

Funciones set.

Funciones get.


Outline47

time3.cpp(1 de 3)

1 // Fig. 6.19: time3.cpp2 // Definición de funciones miembro para clase Time.3 #include <iostream>4 #include <iomanip>5 using std::cout;6 using std::setfill;7 using std::setw;8 // incluye definición de clase Time en time3.h9 #include "time3.h"10 11 // Función constructur para inicializar datos private;12 // llama a la función miembro setTime para fijar las variables;13 // los valores predeterminados son 0 (ver definición de clase)14 Time::Time( int hr, int min, int seg ) 15 { 16 setTime( hr, min, seg ); 17 } // fin de constructor Time18 19 // fija valores de hora, minuto y segundo20 void Time::setTime( int h, int m, int s )21 {22 setHora( h ); 23 setMinuto( m );24 setSegundo( s );25 } // fin de función setTime26

Llama a funciones set para realizar la comprobación de validez.


Outline48

time3.cpp(2 de 3)

27 // fija el valor de hora 28 void Time::setHora( int h ) 29 { 30 hora = ( h >= 0 && h < 24 ) ? h : 0;31 } // fin de función setHora 32 33 // fija el valor de minuto34 void Time::setMinuto( int m ) 35 { 36 minuto = ( m >= 0 && m < 60 ) ? m : 0;37 } // fin de función setMinuto38 39 // fija el valor de segundo40 void Time::setSegundo( int s ) 41 { 42 segundo = ( s >= 0 && s < 60 ) ? s : 0;43 } // fin de función setSegundo 44 45 // devuelve el valor de hora 46 int Time::getHora() 47 { 48 return hora; 49 } // fin de función getHora50 51 // devuelve el valor de minuto 52 int Time::getMinuto() 53 { 54 return minuto; 55 } // fin de función getMinuto56

Funciones set realizan comprobación de validez antes de modificar los datos.

Funciones get permiten al cliente leer datos.


Outline49

time3.cpp(3 de 3)

57 // devuelve el valor de segundo 58 int Time::getSegundo() 59 { 60 return segundo; 61 } // fin de función getSegundo62 63 // imprime Time en formato universal64 void Time::imprimeUniversal()65 {66 cout << setfill( '0' ) << setw( 2 ) << hora << ":"67 << setw( 2 ) << minuto << ":"68 << setw( 2 ) << segundo;69 } // fin de función imprimeUniversal70 71 // imrpime Time en formato estándar72 void Time::imrprimeEstandar()73 {74 cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 )75 << ":" << setfill( '0' ) << setw( 2 ) << minuto76 << ":" << setw( 2 ) << segundo 77 << ( hora < 12 ? " AM" : " PM" );78 } // fin de función imprimeEstandar

Función get permite al cliente leer datos.


Outline50


1 // Fig. 6.20: fig06_20.cpp2 // Demostración de las funciones set y get de la clase Time3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 // incluye definición de clase Time de time3.h9 #include "time3.h"10 11 void incrementaMinutos( Time &, const int ); // prototipo12 13 int main()14 {15 Time t; // crea objeto Time16 17 // fija la hora usando funciones set individuales18 t.setHora( 17 ); // fija hora a valor válido19 t.setMinuto( 34 ); // fija minuto a valor válido20 t.setSegundo( 25 ); // fija segundo a valor válido21

Invoca funciones set para fijar valores válidos.


Outline51


22 // usa funciones get para obtener hora, minuto y segundo23 cout << "Resultado de fijar valores válidos:\n" 24 << " Hora: " << t.getHora()25 << " Minuto: " << t.getMinuto()26 << " Segundo: " << t.getSegundo();27 28 // fija la hora usando funciones set individuales 29 t.setHora( 234 ); // hora no válida fijada a 030 t.setMinuto( 43 ); // fijo minuto a valor válido31 t.setSegundo( 6373 ); // segundo no válido fijado a 032 33 // imprimo hora, minuto y segundo después de fijar34 // valores no válidos para hora y segundo35 cout << "\n\nResultado de intentar fijar hora y segundo no válidos:\n"36 << " Hora: " << t.getHora()37 << " Minuto: " << t.getMinuto()38 << " Segundo: " << t.getSegundo() << "\n\n";39 40 t.setTime( 11, 58, 0 ); // fijo hora41 incrementaMinutos( t, 3 ); // incrementalos minutos de t en 342 43 return 0;44 45 } // fin de main46

Intento de fijar valores no válidos usando funciones set.

Valores no válidos implican fijar datos miembro a 0.

Modifico datos miembro usando función setTime.


Outline52


fig06_20.cppsalida

47 // suma un número específico de minutos a un objeto Time48 void incrementaMinutos( Time &tt, const int cont )49 {50 cout << "Incrementando minuto " << cont << " veces:\n";51 cout << "Hora inicial: ";52 tt.imprimeEstandar();53 54 for ( int i = 0; i < cont; i++ ) {55 tt.setMinuto( ( tt.getMinuto() + 1 ) % 60 ); 57 if ( tt.getMinuto() == 0 )58 tt.setHora( ( tt.getHora() + 1 ) % 24);60 cout << "\nminuto + 1: ";61 tt.imprimeEstandar();63 } // fin del for65 cout << endl;67 } // fin de la función incrementaMinutos

Usa funciones get para leer datos y funciones set para modificarlos.

Resultado de fijar valores válidos:

Hora: 17 Minuto: 34 Segundo: 25

Resultado de intentar fijar hora y segundo no válidos:

Hora: 0 Minuto: 43 Segundo: 0

Incrementando minuto 3 veces:

Hora inicial: 11:58:00 AM

minuto + 1: 11:59:00 AM

minuto + 1: 12:00:00 PM

minuto + 1: 12:01:00 PM

Intentar fijar datos miembros a valores no válidos implica un mensaje de error y que los datos miembro se fijen a 0.


53

6.9 Asignación por copia predeterminada a nivel de miembro

• Asignación de objetos– Operador de asignación (=)

• Puede asignar un objeto a otro objeto del mismo tipo

• Por defecto: asignación a nivel de miembro

– Cada miembro del objeto a la derecha de la asignación se copia en el mismo miembro del objeto a la izquierda

• Paso y devolución de objetos– Los objetos se pueden pasar como argumentos de función

– Los objetos pueden ser devueltos por funciones

– Por defecto: llamada-por-valor• Se pasa o devuelve una copia del objeto


Outline54

fig06_24.cpp (1 de 2)

1 // Fig. 6.24: fig06_24.cpp 2 // Demostración de asignación entre objetos de una clase3 // usando asignación predeterminada a nivel de miembro.4 #include <iostream>5 using std::cout;6 using std::endl;7 8 // definición de clase Fecha9 class Fecha {10 public:11 Fecha( int = 1, int = 1, int = 1990 ); // constructor predeterminado12 void imprime();13 private:14 int mes;15 int dia;16 int anho;17 }; // fin de clase Fecha18 19 // Constructor Fecha sin comprobación de rango20 Fecha::Fecha( int m, int d, int a )21 {22 mes = m;23 dia = d;24 anho = a;25 } // fin de constructor Fecha26


Outline55

fig06_24.cpp

(2 de 2)

fig06_24.cpp

salida

27 // imprime Fecha en formato dd-mm-aaaa28 void Fecha::imprime() 29 { 30 cout << dia << '-' << mes << '-' << anho; 31 } // fin de función imprime32 33 int main()34 {35 Fecha fecha1( 7, 4, 2002 );36 Fecha fecha2; // fecha2 predeterminada a 1/1/199037 44 cout << “fecha1 = ";45 fecha1.imprime();46 cout << "\nfecha2 = ";47 fecha2.imprime();48 49 fecha2 = fecha1; // asignación predeterminada a nivel de miembro51 cout << "\n\nDespués de copia predeterminada a nivel de miembro, fecha2 = ";52 fecha2.imprime();53 cout << endl;54 55 return 0;57 } // fin de main

fecha1 = 4-7-2002

fecha2 = 1-1-1990

Después de copia predeterminada a nivel de miembro, fecha2 = 4-7-2002

La asignación predeterminada a nivel de miembro asigna de forma individual cada miembro de fecha1 a cada miembro de fecha2.

2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 6: Clases y Abstracción de Datos Índice...

Documents

Transcript of 2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 6: Clases y Abstracción de Datos Índice...