Novena Sesin

Metodologas y Tcnicas de Programacin II

Programacin Orientada a Objeto (POO) C++

El proceso de compilacin Constantes

1

Estado del Programa

Introduccin a la POO Repaso de Conceptos
Historia de la Programacin Conceptos de POO Estndares de Programacin Punteros y Memoria C++ Mi primera Clase E/S Control y Operadores

Clases y O !etos en C++

"so y aplicacin Constructores Constantes e %inline&

#unciones $migas So recarga de #unciones

So recarga
'e Operadores Creacin 'inmica de O !etos

Herencia(

)ipos de *isi ilidad

Herencia M+ltiple

Polimor,ismo
#unciones *irtuales Polimor,ismo y So recarga(

Plantillas

Contenedores

Iteradores

9.1 Repaso de Sesiones Anteriores

Inicializacin y Lim ieza de Objetos
El constructor es una ,uncin sin tipo de retorno y con el mismo nom re .ue la estructura( $l!mno() Podemos usar iniciali/adores en los constructores El destructor tiene la misma ,orma0 sal1o .ue el nom re 1a precedido el operador 232( "#l!mno() 4o de,inimos cuando 5ay punteros

$obrecarga de %!nciones
4a so recarga de ,unciones y los argumentos por de,ecto ayudan a escri ir menos cdigo y a 5acerlo ms legi le(
Pareja(int n); Pareja(int a, int b); Pareja(int a, int b=-1);

Recordemos .ue una ,uncin es un nom re .ue le ponemos a una /ona de memoria en la .ue 5ay unas instrucciones para el procesador( "na 1aria le 6o !ecto7 tam i8n es un nom re de una /ona de memoria en la .ue 5ay unos datos( 9

9.1 Repaso de Sesiones Anteriores

&so de $obrecarga y #rg!mentos
struct punto3D { float x, y, z; }; class punto { public: punto(float xi, float yi, float zi=0) : x(xi), y(yi), z(zi) {} punto(punto3D p) : x(p.x), y(p.y), z(z.y) {} void Asignar(float xi, float yi, float zi) { x = xi; y = yi; z = zi; } } private: float x, y, z; }; } void Ver() { cout <<"("<<x<<"," << y <<","<<z<< ")" << endl; { Asignar(p.x, p.y, p.z);

or de'ecto
void Asignar(punto3D p)

9.2 Compilacin y Enlazado

Com ilacin y (nlazado
$lumno(5
include Alumno.h

or se arado (re aso)

$lumnoM-(5
include Alumno.h include AlumnoM2.h include AlumnoM2.h

$lumno(cpp

$lumnoM-(cpp

test:main(cpp

Compilador

Compilador

Compilador

$lumno(o !

$lumnoM-(o !
Enla/ador

test:main(o !

Practica;(e<e =

9.2 Constantes
Orgenes de const
4a pala ra reser1ada %const& se incorpora a C++ primero y posteriomente a C( Se 5a utili/ado para 1arios propsitos a lo largo del tiempo0 y esto puede generar cierta con,usin al principio( En esta sesin .ueremos aclarar> ?Cundo usar const@ ?Por .u8 usar const@ ?Cmo usar const@ El moti1o unicial para usar const ,ue para eliminar el uso de la directi1a de compilacin Ade,ine para sustitucin de 1alores( const se usa para punteros0 argumentos de ,unciones0 retornos de ,unciones0 o !etos y m8todos(
B

9.2 Constantes
$!stit!cin de )alores
#define NOTA_ESPERADA 8

El preprocesador 5ace un reempla/amiento te<tual y no reali/a ninguna compro acin de tipo( 6$ntes de compilar7 4a sustitucin de 1alores introduce pe.ueCos pro lemas .ue pueden ser e1itados usando 1alores const( DO)$:ESPER$'$ no contiene in,ormacin so re el tipo .ue esperamos0 y el compilador no puede compro arla( Esto puede dar lugar a errores difciles de encontrar 6poco reutili/a le7( const ayuda a eliminar estos pro lemas( Podemo usar const con los tipos sicos 6c5ar0 int0 ,loat y dou le7 y sus 1ariantes asE como con clases como 1eremos(
const float nota_esperada = 8; cont int cantidad = 19; Alumnos curso[cantidad];

9.2 Constantes
Constantes seg!ras
$dems de para sustituir 1alores podemos usar const para asegurarnos de .ue una 1aria le cuyo 1alor sa emos .ue no 1a a cam iar durante su 1ida en nuestro programa( El compilador producir un mensa!e de error 6o mensa!e de ayuda7(
const int i = 100; // Constante Tpica const int j = i + 10; // Valor constante calculado como expresin constante long address = (long)&j; // Obliga al compilador a almacenar j. char buf[j + 10]; int main() { cout << "Introduzca un caracter, por favor:"; const char c = cin.get(); // Inicializamos de algo que no sabemos a priori const char c2 = c + a; cout << c2; // MAL:-> c2 } << cin; // Constante de expresin constante. // Pero j sigue siendo una expresin constante.

9.2 Constantes
#rrays (*ectores)
Cuando aplicamos const a un array normalmente no nos a5orramos espacio en memoria( %Con!unto de datos en memoria .ue no pueden modi,icarse&

const int i[] = { 1, 2, 3, 4 }; //! float f[i[3]]; // MAL! struct S { int i, j; }; const S s[] = { { 1, 2 }, { 3, 4 } }; //! double d[s[1].j]; // MAL! int main() {}

9.2 Constantes
P!nteros
Hay dos opciones cuando aplicamos const a un puntero> Hueremos .ue sea constante lo .ue apunta el puntero Hueremos .ue se constante la direccin del puntero( P!ntero a algo constante+
// p es un puntero que apunta a: // un entero constante. const int* p; const int *p; // Esta forma es igual, pero mejor // no la usamos. Confunde. // p es un puntero a: // un entero que es constante. int const* p;

?Cmo ser si lo .ue .ueremos es sea el puntero el constante(

1I

9.2 Constantes
P!nteros
P!ntero constante+ Osea .ue su 1alor J .ue es una direccin K no puede cam iar(
// w es un puntero constante que apunta a: // int i=3; int* const w = &i; int * const w = &i; *w = 2; w // Est bien o est mal? un entero.

= &j; // Y esto?

Podemos com inar constantes>

int d = 1;

punteros

constantes

.ue

apuntan

elementos

const int* const x = &d;

// (1)

int const* const x2 = &d; // (2) Mejor usamos la forma (1)

11

9.2 Constantes
#rg!mentos de %!nciones
En el caso de .ue pasemos los argumentos por 1alor 6se 5ace copia de los datos7 no tiene sentido para el cliente utili/ar const( 'entro de la ,uncin tiene el signi,icado> %El argumento no se puede cam iar&(
void funcion(const int i) { i++; } // Ilegal int f3() { return 1; } const int f4() { return 1; } .......... const int j = f3(); // Bien. int k = f4(); ........... // Bien tambin

,etorno

or *alor constante

En este caso se est diciendo .ue el 1alor de la 1aria le original 6en el m ito de la ,uncin7 no se modi,icar( Como lo est de1ol1iendo por 1alor0 es la copia lo .ue se retorna0 de modo .ue el 1alor original nunca se podr modi,icar(
const int g();

'e1ol1er por 1alor como constante se 1uel1e importante cuando se trata con tipos de,inidos por el programador(
1-

9.2 Constantes
-e*ol*iendo *alores constantes
Si de1ol1emos un tipo sico lo me!or es no utili/ar const 6no aporta muc5o7( Si una ,uncin de1uel1e un o !eto por 1alor como constante0 el 1alor de retorno de la ,uncin no puede ser un recipiente(
class X { int i; public: X(int ii = 0); void modify(); }; X::X(int ii) { i = ii; } void X::modify() { i++; } X f5() { return X(); } } f5() = X(1); f5().modify(); // No compilan: //! f7(f5()); // Causes compile-time errors: //! f6() = X(1); // BIEN // BIEN } void f7(X& x) { // Pass by non-const reference x.modify(); const X f6() { return X();

19

9.2 Constantes
Objetos Tem orales
Como ya .emos *isto en determinadas situaciones se crean o !etos temporales .ue se construyen y se destruyen( Estos o !etos no se 1en0 los crea y los destruye el compilador seg+n sus necesidades( Repasad en la sesin ; el programa cuantos(cpp( 4os o !etos temporales siempre se crean como constantes( Hacer algo .ue cam ie un temporal es casi seguro un error( 6L7 Re1isa el cdigo anterior teniendo esto en cuenta(((
f5() = X(1); f5().modify();

Estas sentencias son acepta les para el compilador pero son pro lemticas( ,=67 de1uel1e algo de la clase M0 pero en cuanto se e1al+a la e<presin el o !eto de1uelto desaparece( Pro a lemente un cdigo asE ser errneo(
1N

9.2 Constantes
Paso y retorno de direcciones
Si pasamos o retornamos una direccin 6puntero o re,erencia70 el programador cliente puede recoger y modi,icar el 1alor original(
void t(int*) {} void u(const int* cip) { //! *cip = 2; int i = *cip; } const char* v() {// La direccin de un arr. esttico return "result of function v()"; } const int* const w() { static int i; return &i; } // ?? // ?? int main() { int x = 0; int* ip = &x; const int* cip = &x; t(ip); u(ip); u(cip); // ?? // ?? u() es ms general // ?? que t() !! //! t(cip); // ??

//! int* ip2 = cip; // ??

//! char* cp = v(); // ?? const char* ccp = v(); // ?? //! int* ip2 = w(); // ?? const int* const ccip = w(); // ?? const int* cip2 = w(); // ?? //! *w() = 1; // ?? } //Mira pgina 219 de Pensar en C++

1=

9.2 Constantes
,ecomendacin de aso de arg!mentos en C++
$ntes de e<istir las re,erencias la +nica ,orma de> K modi,icar algo dentro de una ,uncin era usar un puntero( K proteger algo de ser tocado dentro era usar paso por 1alor 6costoso7( En C++ lo me!or es utili/ar una re,erencia constante en lugar de paso por 1alor> K Para el programador cliente es lo mismo( K Do 5ay con,usin con los punteros( K Para el creador es ms e,iciente pasar una direccin .ue un o !eto entero( $dems es posi le pasarle un o !eto temporal a una ,uncin .ue reci e una re,erencia constante( Con un puntero no podemos( *eamos un e!emplo>

1B

9.2 Constantes
Paso de #rg!mentos mediante re'erencias
class X {}; X f() { return X(); } void g1(X&) {} void g2(const X&) {} int main() { g1(f()); g2(f()); } // Bien o mal? Piensa cmo son los objetos temporales. // Bien o mal? eh? // Retorno por valor // Paso por referencia no-constante // Paso por referencia constante

,67 retorna un o !eto de la clase M por 1alor( Esto signi,ica .ue cuando tome el 1alor de retorno y lo pase inmediatamente a otra ,uncin como en las llamadas a g167 y g-670 se crea un temporal y los temporales son siempre constantes( Por eso0 la llamada a g167 es un error pues g167 no acepta una re,erencia constante0 mientras .ue la llamada a g-67 si es correcta(
1;

9.2 Constantes
&so de const y clases
En la lista de iniciali/acin del constructor( 4a iniciali/acin de la lista ocurre antes de e!ecutar el cuerpo del constructor 6O(((((P7( 4as constantes se de en iniciali/ar en el punto en .ue se crean0 y al llegar al cuerpo del constructor de e estar ya iniciali/ada> OQ0 utili/amos la lista de iniciali/acin del constructor(
class RecienNacido { const int peso_; public: RecienNacido(int peso); void imprimir(); }; RecienNacido::RecienNacido(int peso) : peso_(peso) {} void RecienNacido::imprimir() { cout << peso_ << endl; } RecienNacido a(1), b(2), c(3); a.imprimir(), b.imprimir(), c.imprimir();

1F

9.2 Constantes
Objetos y Mtodos Constantes
"n o !eto constante se de,ine del mismo modo para un tipo de,inido por el usuario .ue para un tipo sico del lengua!e(
const int i = 1; const Alumno a(2);

Para .ue el compilador imponga .ue el o !eto sea constante0 de e asegurar .ue el o !eto no tiene atri utos .ue 1ayan a cam iar durante el tiempo de 1ida del o !eto( Si durante la de,inicin de la ,uncin se modi,ica alg+n miem ro o se llama alg+n m8todo no constante0 el compilador emitir un mensa!e de error( Por eso0 est garanti/ado .ue los miem ros .ue declare const se comportarn del modo esperado( Recordad .ue colocar const delante de la declaracin del m8todo indica .ue el 1alor de retorno es constante( Hay .ue colocar el especi,icador const despu8s de la lista de argumentos(
1G

9.2 Constantes
Objetos y Mtodos Constantes
class X { int i_; public: X(int i); int f() const; }; X::X(int i) : i_(i) {} int X::f() const { return i_; } int main() { X x1(10); const X x2(20); x1.f(); x2.f(); }

4a pala ra const de e incluirse tanto en la declaracin como en la deRnicin del m8todo( Como ,67 es un m8todo constante0 si intenta modi,icar de alguna ,orma o llamar a otro m8todo .ue no sea constante0 el compilador in,ormar8 de un error( "n miem ro constante puede llamarse tanto desde o !etos constantes como desde no constantes de ,orma segura( "n m8todo .ue no modi,ica ning+n atri uto se de erEa escri ir como constante y asE se podrEa usar desde o !etos constantes(
-I

9.3 Resumen
Constantes
4a pala ra reser1ada para de,inir constantes es const const nos permite de,inir como constantes> *aria les( O !etos( $rgumentos de ,unciones( Punteros( M8todos( Elimina el uso de constantes sim licas con Sde,ineS para sustitucin de 1alores por el preprocesador sin perder sus 1enta!as0 aCadiendo compro acin de tipos y 5aciendo nuestro cdigo ms seguro( (l !so de la llamada /constancia e0acta1 (const correctness) es decir2 el !so de const en todo l!gar donde sea osible2 !ede ser !n sal*a*idas ara m!c.os royectos3
-1