DcimoprimeraSesin

Metodologas y Tcnicas de Programacin II

Programacin Orientada a Objeto (POO) C++

Control de Nombres
1

EstadodelPrograma
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 Objetos en C++

Uso y aplicacin Constructores Constantes e inline

Funciones Amigas Sobrecarga de Funciones

Sobrecarga
De Operadores Creacin Dinmica de Objetos

Herencia.

Tipos de Visibilidad

Herencia Mltiple

Polimorfismo
Funciones Virtuales Polimorfismo y Sobrecarga.

Plantillas

Contenedores

Iteradores

11.1RepasodeSesionesAnteriores
const
El motivo unicial para usar const fue para eliminar el uso de la directiva de compilacin #define para sustitucin de valores. Tiene ventajas sobre #define.
constfloatnota_esperada=8; contintcantidad=19; Alumnoscurso[cantidad]; #defineNOTA_ESPERADA8

Punteros constantes:
// p es un puntero que apunta // a:unenteroconstante. constint*p; constint*p; //wesunpunteroconstante //queapuntaa:unentero. inti=3; int*constw=&i; *w=2;//Estbienoestmal?

En C++ lo mejor es utilizar una referencia constante en lugar de paso por valor. Un mtodo que no modifica ningn atributo se debera escribir como constante y as se podra usar desde objetos constantes.
3

11.1RepasodeSesionesAnteriores
funciones inline
Sustituye la utilizacin de macros que es muy comn en la programacin en C. Se pens para dotar al lenguaje C++ de mayor eficiencia. Es una sugerencia para el compilador. Hay dos maneras de definir un mtodo de una clase como inline. Es preferible la que se utiliza en la implementacin y no en la declaracin de la clase.

11.2ControldeNombres
Conceptos previos
La creacin de nombres es una actividad fundamental en la programacin y, cuando un proyecto empieza a tomar grandes dimensiones, el nmero de nombres puede fcilmente llegar a ser inmanejable. En C++ podemos controlar: Creacin y Visibilidad de nombres. Lugar dnde se almacenan. Enlazado de nombres. Vamos a ver: static y cmo controla el almacenamiento y la visibilidad. namespace para controlar los nombres.
5

11.2ControldeNombres
Conceptos previos
La creacin de nombres es una actividad fundamental en la programacin y, cuando un proyecto empieza a tomar grandes dimensiones, el nmero de nombres puede fcilmente llegar a ser inmanejable. En C++ podemos controlar: Creacin y Visibilidad de nombres. Lugar dnde se almacenan. Enlazado de nombres. Vamos a ver: static y cmo controla el almacenamiento y la visibilidad. namespace para controlar los nombres.
6

11.2ControldeNombres
static

Dos usos bsicos: 1.- Se almacena la variable o el objeto una sola vez en una direccin de memoria fija. El objeto o la variable se crea en un rea de datos esttica especial en lugar de la pila. 2.- Variable local para un mbito en particular. Con static controlamos la visibilidad de un nombre que no puede ser visto fuera del mbito o de una clase.

11.2ControldeNombres
Variables estticas dentro de funciones
Si tenemos una variable local dentro de una funcin, cada vez que se llama a la funcin: Se reserva espacio para esa variable en la pila. Si hay inicializador: Se realiza la inicializacin.

Si utilizamos static: El almacenamiento no se realiza en la pila sino en el rea de datos estticos. La inicializacin slo se realiza la primera vez.

11.2ControldeNombres
Variables estticas dentro de funciones
charun_caracter(void) { staticconstchar* s=ABCDEFGHIJK; if(*s==\0) return0; return*s++; } intmayor(inti) { staticintmayor=0; if(i>mayor) { mayor=i; } returnmayor; } cout<<mayor(5)<<mayor(5)<<endl; cout<<mayor(7)<<mayor(7)<<endl; cout<<mayor(5)<<mayor(5)<<endl; cout<<mayor(9)<<mayor(5)<<endl; } intmain() { charc; while((c=un_caracter())!=0) cout<<c<<endl;

11.2ControldeNombres
Objetos estticos dentro de funciones
Hemos visto lo que ocurre con variables (en realidad objetos de alguno de los tipos o clases bsicas del lenguaje) Las reglas para objetos estticos: Son las mismas. El objeto requiere ser inicializado (a travs de sus constructores). Si no especicamos argumentos en los constructores cuando denimos un objeto esttico, la clase deber tener un constructor por defecto.
voidfuncion(void) { staticAlumnoa(pepe,5); staticAlumnob;//Constructorpordefecto!! .................. }

y cundo se llama a los destructores?

10

11.2ControldeNombres
Objetos estticos: Destructores
classObj { charc;//Identificador public: Obj(charcc):c(cc){cout<<"Constructorde"<<c<<endl;} Obj(){cout<<"Destructorde"<<c<<endl;} }; Obja(a);//Global voidf() { staticObjb(b); } intmain() { f(); cout<<"leavingmain()"<<endl; } Constructordea Constructordeb Saliendodemain() Destructordeb Destructordea

11

11.2ControldeNombres
Espacios de Nombres
Los nombres pueden estar anidados dentro de clases. Son diferentes los mtodos imprimir() de las clases: Alumno Coche Coordenada Perro Pero los nombres de: Funciones globales. Variables globales. Clases.

No se pueden repetir....

Estn dentro de que llamamos el espacio de nombres global.

12

11.2ControldeNombres
Espacios de Nombres
Enun proyecto grande la falta de control sobre quin ha utilizado ya los nombres en el espacio de nombres global puede traernos problemas. Una solucin comn: Nombres de funciones muy largos intentando evitar repeticiones. _METODOS_2_2007_funcion_imprimir_alumnos(Lista* p); Pero no es muy elegante. Utilizaremos namespace para dividir el espacio de nombres globales en partes ms manejables. Con namespace creamos un nuevo espacio de nombres.
13

11.2ControldeNombres
Crear un espacio de nombres
Muy similar a una clase:
namespacemi_libreria { //Declaraciones }

Una definicin namespace slo puede aparecer en un rango global de visibilidad o dentro de otro namespace. Podemos utilizar otro nombre que nos venga menjor a un espacio cuyo nombre ha puesto alguien de forma enrevesada (acordaos del ejemplo de antes).
namespace_METODOS_II_2007_NOMBRES_ { classAlumno{/*...*/}; classAlumnoM2{/*...*/}; //... } //Demasiadolago.Quieroahorrarescritura... namespaceM2=_METODOS_II_2007_NOMBRES_; intmain(){M2.Alumnoa;}

14

11.2ControldeNombres
namespaceX { classY { staticinti; public: voidf(); }; classZ; voidfunc(); } intX::Y::i=9; classX::Z { intu,v,w; public: Z(inti); intg(); }; }

Usando los espacios de nombres

{

X::Z::Z(inti) u=v=w=i; } intX::Z::g() { returnu=v=w=0; } voidX::func() { X::Za(1); a.g(); } voidfuncion() { usingnamespaceX; Zb(1);

15

11.2ControldeNombres
Espacios de Nombres
Con la directiva using es como si estuviramos dentro de la definicin del espacio de nombres. Con using no nos hace falta utilizar en el mbito donde nos situemos el nombre del espacio de nombres al que nos referimos.
#ifndefUSINGDECLARATION_H #defineUSINGDECLARATION_H namespaceU{ inlinevoidf(){} inlinevoidg(){} } namespaceV{ inlinevoidf(){} inlinevoidg(){} } #endif//USINGDECLARATION_H #include"UsingDeclaration.h" namespaceQ{ usingU::f; usingV::g; //... } voidm(){ usingnamespaceQ; f();//LlamadaaU::f(); g();//LlamadaaV::g(); } intmain(){}

16

11.2ControldeNombres
Espacios de Nombres
#include<iostream> namespaceuno{ intx; } namespacedos{ intx; } usingnamespaceuno; intmain(){ x=10; dos::x=30; std::cout<<x<<","<<dos::x<<std::endl; std::cin.get(); return0; }

17

11.2ControldeNombres
Espacios de Nombres annimos
namespaceNombre { intf(); chars; voidg(int); } namesmace { intx=10; } //xslosepuededesdeestepuntohastaelfinaldelfichero //Resultainaccesibledesdecualquierotropuntoofichero namespaceNombre{ intf(){ returnx; } }

18

11.3Resumen
Static
Podemos controlar el almacenamiento de nuestros objetos y variables. Podemos controlar el mbito en el que se ven.

Espacios de Nombres
Utilzamos la palabra reservada namespace. Nos ayudan a dividir el espacio de nombres global de forma que podamos repetir nombres de funciones, clases y variables. Es una declaracin y se suele utilizar por tanto en los ficheros de cabecera.

19