En el lenguaje C++ las funciones miembro se declaran, se definen y se llaman. En el lenguaje Java las funciones miembro o métodos solamente se definen y se llaman.
El nombre de las funciones miembro o métodos comieza por letra minúscula y deben sugerir acciones (mover, calcular, etc.). La definición de una función tiene el siguiente formato:
tipo nombreFuncion(tipo parm1, tipo parm2, tipo parm3){
//...sentencias
}
Entre las llaves de apertura y cierre se coloca la definición de la función. tipo indica el tipo de dato que puede ser predefinido int, double, etc, o definido por el usuario, una clase cualquiera.
Para llamar a un función miembro o método se escribe
retorno=objeto.nombreFuncion(arg1, arg2, arg3);
Cuando se llama a la función, los argumentos arg1, arg2, arg3 se copian en los parámetros parm1, parm2, parm3 y se ejecutan las sentencias dentro de la función. La función finaliza cuando se llega al final de su bloque de definición o cuando encuentra una sentencia return.
Cuando se llama a la función, el valor devuelto mediante la sentencia return se asigna a la variable retorno.
Cuando una función no devuelve nada se dice de tipo void. Para llamar a la función, se escribe
objeto.nombreFuncion(arg1, arg2, arg3);
Estudiaremos más adelante con más detalle como se definen las funciones.
Una función suele finalizar cuando llega al final del bloque de su definición
void funcion(....){
//sentencias...
}
Una función puede finalizar antes del llegar al final de su definición
void funcion(....){
//sentencias...
if(condicion) return;
//sentencias..
}
Una función puede devolver un valor (un tipo de dato primitivo o un objeto).
double funcion(....){
double suma=0.0;
//sentencias...
return suma;
}
Cualquier variable declarada dentro de la función tiene una vida temporal, existiendo en memoria, mientras la función esté activa. Se trata de variables locales a la función. Por ejemplo:
void nombreFuncion(int parm){
//...
int i=5;
//...
}
La variable parm, existe desde el comienzo hasta el final de la función. La variable local i, existe desde el punto de su declaración hasta el final del bloque de la función.
Se ha de tener en cuenta que las funciones miembro tienen acceso a los miembros dato, por tanto, es importante en el diseño de una clase decidir qué variables son miembros dato, qué variables son locales a las funciones miembro, y qué valores les pasamos a dichas funciones. Los ejemplos nos ayudarán a entender esta distinción.
Hemos definido los atributos o miembros dato de la clase Rectangulo, ahora le vamos añadir un comportamiento: los objetos de la clase Rectangulo o rectángulos sabrán calcular su área, tendrán capacidad para trasladarse a otro punto del plano, sabrán si contienen en su interior un punto determinado del plano.
La función que calcula el área realizará la siguiente tarea, calculará el producto del ancho por el alto del rectángulo y devolverá el resultado. La función devuelve un entero es por tanto, de tipo int. No es necasario pasarle datos ya que tiene acceso a los miembros dato ancho y alto que guardan la anchura y la altura de un rectángulo concreto.
class Rectangulo{
int x;
int y;
int ancho;
int alto;
int calcularArea(){
return (ancho*alto);
}
}
A la función que desplaza el rectángulo horizontalmente en dx, y verticalmente en dy, le pasamos dichos desplazamientos, y a partir de estos datos actualizará los valores que guardan sus miembros dato x e y. La función no devuelve nada es de tipo void.
class Rectangulo{
int x;
int y;
int ancho;
int alto;
void desplazar(int dx, int dy){
x+=dx;
y+=dy;
}
}
La función que determina si un punto está o no en el interior del rectángulo, devolverá true si el punto se encuentra en el interior del rectángulo y devolverá false si no se encuentra, es decir, será una función del tipo boolean. La función necesitará conocer las coordenadas de dicho punto. Para que un punto de coordenadas x1 e y1 esté dentro de un rectángulo cuyo origen es x e y, y cuyas dimensiones son ancho y alto, se deberá cumplir a la vez cuatro condiciones
x1>x y a la vez x1<x+ancho
También se debe cumplir
y1>y y a la vez y1<y+alto
Como se tienen que cumplir las cuatro condiciones a la vez, se unen mediante el operador lógico AND simbolizado por &&.
class Rectangulo{
int x;
int y;
int ancho;
int alto;
boolean estaDentro(int x1, int y1){
if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){
return true;
}
return false;
}
}
En el lenguaje Java, si la primera condición es falsa no se evalúan las restantes expresiones ya que el resultado es false. Ahora bien, si la primera es verdadera true, se pasa a evaluar la segunda, si ésta el falsa el resultado es false, y así sucesivamente.
domingo, 19 de julio de 2015
sábado, 18 de julio de 2015
4.1 Templates (plantillas)
Plantillas
Recurso que ofrece el lenguaje C++ para ganar generalidad en la definición de soluciones, estos permiten declarar funciones o clases dejando sin especificar el tipo de alguno de sus parámetros y los datos (en el caso de las funciones) o el tipo de algunos de sus miembros (en el caso de las clases).
Plantillas de funciones: Es un modelo de función que el compilador C++ usará para construir diferentes versiones de una misma función , según los tipos de datos que se especifiquen al invocar a la misma. La plantilla permite escribir funciones que difieren exclusivamente en el tipo de datos que manejan.
Sintaxis:
template <class T1, class T2>
donde:
template es la palabra reservada al igual que clase T1,T2 son los tipos de datos genéricos.
Ejemplos:
#include <stdlib.h>
#include <iostream>
#include <conio.h>
using namespace std;
/*
int maximo (int a , int b)
{if (a<b)
return b;
else
return a;}
float maximo (float a, float b)
{if (a<b)
return b;
else
return a;
}*/
template <class T1>//T1 tipo generico entra lo que sea y sale el resultado bien mil :)
T1 maximo(T1 a, T1 b)
{
if (a<b)
return b;
else
return a;
}
int main ()
{
char d='B', e='C',f;
int a=-3,b=-10,c;
float w=-5.7,x=8.9,y;
c=maximo(a,b);
y=maximo(w,x);
cout<<"maximo("<<a<<")("<<b<<")"<<"="<<c<<endl;
cout<<"maximo("<<w<<")("<<x<<")"<<"="<<y<<endl;
f= maximo (d,e);
cout<<"maximo("<<d<<")("<<e<<")"<<"="<<f<<endl;
system ("pause");
}
Plantillas de clases:
Permiten definir versiones de una misma clase que difieran en el tipo de dato de alguno(s) de sus miembros. Es decir, crea el modelo de una clase el cual permitirá definir distintas instancias de la misma para diferentes tipos de datos.
Sintaxis:
template <class T>
class plantilla clase
{
private: t atributo
.
.
.
public:
.
.
.
};
class punto
{ private:
float x; --> int x; --> long int x;
float y; -->int y; --> long int y;
public:
.
.
.
};
template class <T>
class punto
{ private:
T x;
T y;
public:
.
.
.
};
Ejemplo 1:
#include <stdlib.h>
#include <iostream>
#include <conio.h>
using namespace std;
template < class T1, class T2>
T1 maximo(T1 a, T2 b)//Elige dos tipos de datos diferentes :D
{
if (a<b)
return b;
else
return a;
}
int main ()
{system ("color 5F");
cout<<"maximo= "<< maximo (3,'A')<<endl;
cout<<"maximo= "<< maximo (-100,-98)<<endl;
cout<<"maximo= "<< maximo ('Z',20)<<endl;
system ("pause");
}
Ejemplo 2:
#include <stdlib.h>
#include <iostream>
#include <conio.h>
using namespace std;
template <class T1,class T2>
class ejemploplantilla
{
private:
T1 dato1;
T2 dato2;
public:
ejemploplantilla(T1 d1, T2 d2) {dato1=d1;dato2=d2;}
void imprimedato(){ cout<<"Dato 1: " <<dato1<<endl;
cout<<"Dato 2: " <<dato2<<endl;
}
};
void usaplantilla()
{
ejemploplantilla <int, float> objp(1,6.5);
objp.imprimedato();
cout<<endl;
ejemploplantilla <char,int> objp2('A',-85);
objp2.imprimedato();
cout<<endl;
getch();
}
int main ()
{
system ("color 5F");
usaplantilla ();
return 0;
}
Recurso que ofrece el lenguaje C++ para ganar generalidad en la definición de soluciones, estos permiten declarar funciones o clases dejando sin especificar el tipo de alguno de sus parámetros y los datos (en el caso de las funciones) o el tipo de algunos de sus miembros (en el caso de las clases).
Plantillas de funciones: Es un modelo de función que el compilador C++ usará para construir diferentes versiones de una misma función , según los tipos de datos que se especifiquen al invocar a la misma. La plantilla permite escribir funciones que difieren exclusivamente en el tipo de datos que manejan.
Sintaxis:
template <class T1, class T2>
donde:
template es la palabra reservada al igual que clase T1,T2 son los tipos de datos genéricos.
Ejemplos:
#include <stdlib.h>
#include <iostream>
#include <conio.h>
using namespace std;
/*
int maximo (int a , int b)
{if (a<b)
return b;
else
return a;}
float maximo (float a, float b)
{if (a<b)
return b;
else
return a;
}*/
template <class T1>//T1 tipo generico entra lo que sea y sale el resultado bien mil :)
T1 maximo(T1 a, T1 b)
{
if (a<b)
return b;
else
return a;
}
int main ()
{
char d='B', e='C',f;
int a=-3,b=-10,c;
float w=-5.7,x=8.9,y;
c=maximo(a,b);
y=maximo(w,x);
cout<<"maximo("<<a<<")("<<b<<")"<<"="<<c<<endl;
cout<<"maximo("<<w<<")("<<x<<")"<<"="<<y<<endl;
f= maximo (d,e);
cout<<"maximo("<<d<<")("<<e<<")"<<"="<<f<<endl;
system ("pause");
}
Plantillas de clases:
Permiten definir versiones de una misma clase que difieran en el tipo de dato de alguno(s) de sus miembros. Es decir, crea el modelo de una clase el cual permitirá definir distintas instancias de la misma para diferentes tipos de datos.
Sintaxis:
template <class T>
class plantilla clase
{
private: t atributo
.
.
.
public:
.
.
.
};
class punto
{ private:
float x; --> int x; --> long int x;
float y; -->int y; --> long int y;
public:
.
.
.
};
template class <T>
class punto
{ private:
T x;
T y;
public:
.
.
.
};
Ejemplo 1:
#include <stdlib.h>
#include <iostream>
#include <conio.h>
using namespace std;
template < class T1, class T2>
T1 maximo(T1 a, T2 b)//Elige dos tipos de datos diferentes :D
{
if (a<b)
return b;
else
return a;
}
int main ()
{system ("color 5F");
cout<<"maximo= "<< maximo (3,'A')<<endl;
cout<<"maximo= "<< maximo (-100,-98)<<endl;
cout<<"maximo= "<< maximo ('Z',20)<<endl;
system ("pause");
}
Ejemplo 2:
#include <stdlib.h>
#include <iostream>
#include <conio.h>
using namespace std;
template <class T1,class T2>
class ejemploplantilla
{
private:
T1 dato1;
T2 dato2;
public:
ejemploplantilla(T1 d1, T2 d2) {dato1=d1;dato2=d2;}
void imprimedato(){ cout<<"Dato 1: " <<dato1<<endl;
cout<<"Dato 2: " <<dato2<<endl;
}
};
void usaplantilla()
{
ejemploplantilla <int, float> objp(1,6.5);
objp.imprimedato();
cout<<endl;
ejemploplantilla <char,int> objp2('A',-85);
objp2.imprimedato();
cout<<endl;
getch();
}
int main ()
{
system ("color 5F");
usaplantilla ();
return 0;
}
3.2.2 Herencia múltiple
Algunos lenguajes orientados a objetos, como C++ permiten herencias múltiples, lo que significa que una clase puede heredar los atributos de otras dos superclases. Este método puede utilizarse para agrupar atributos y métodos desde varias clases dentro de una sola.
3.2.1 Herencia Simple.
Cuando sólo se tiene una clase base de la cual hereda la clase derivada, se dice que hay herencia simple (figura 1.a). Sin embargo, la herencia simple no excluye la posibilidad de quede una misma clase base se pueda derivar más de una subclase o clase derivada.
Cuando se necesita representar un concepto general y a partir de éste, conceptos más específicos, resulta conveniente organizar la información usando herencia. Esto permite compartir atributos y métodos ya definidos, evita la duplicidad y, por otra parte, proporciona mayor claridad en la representación que se haga de la información. Es decir, se logra un mejor diseño de la solución del problema. Existen numerosos casos en los cuales se da este tipo de relación. En la Figura 2 se presentan algunos ejemplos de herencia simple.
En la figura 2a, la clase Persona es la clase base y Empleado es la clase derivada. Un objeto de esta clase también es un objeto de la clase “Persona”, por lo tanto tendrá los atributos y métodos de ambas clases. En la figura 2b, la clase Mamífero es la clase base y Vacuno y Equino son las clases derivadas. En este caso, se dice que todo “Vacuno” y todo “Equino” también son objetos de la clase “Mamífero” y en consecuencia tendrán todos los atributos y métodos que heredan de la clase base. La herencia pública permite que los miembros privados de la clase base se puedan acceder sólo por medio de los métodos de dicha clase. Los miembros protegidos de la clase base podrán ser usados por los métodos de las clases derivadas, pero no por sus clientes.
Los miembros públicos estarán disponibles para los métodos de las clases derivadas y para todos sus clientes.
class Base
{ private:
// Miembros declarados en la sección privada: accesibles sólo para miembros de esta clase
protected:
/* Miembros declarados en la sección protegida: accesibles sólo para miembros de esta
clase y de sus derivadas */
public:
// Miembros declarados en la sección pública: accesibles para todos
};
Para declarar una clase derivada de una clase previamente definida se utiliza la siguiente sintaxis:
class Base
{ // Declaración de atributos y métodos de la clase Base
};
// Relación de herencia pública entre las clases Base y Derivada
class Derivada : public Base
{ // Declaración de atributos y métodos de la clase Derivada
};
Con la palabra reservada public en el encabezado de la declaración de la clase “Derivada” se hace referencia a que dicha clase hereda los atributos y métodos de la clase “Base”.
La declaración del constructor de la clase “Derivada” debe incluir un llamado al constructor de la clase “Base”.
Para ello se utiliza la siguiente sintaxis:
Derivada :: Derivada (parámetros) : Base (parámetros propios de la clase Base)
{ // Cuerpo del constructor de la clase Derivada
}
Cuando se declara un objeto del tipo de la clase derivada se invoca al constructor de ésta. De este constructor lo primero que se ejecuta es la llamada al constructor de la clase base, y posteriormente se ejecutan sus propias instrucciones.
En cuanto a los parámetros, al invocar al constructor de la clase base se le deben proporcionar los parámetros que necesita para asignar valores a los atributos propios de la clase base y que la clase derivada hereda. En el cuerpo de la clase derivada se harán las asignaciones correspondientes a los atributos propios de esta clase.
Los miembros públicos estarán disponibles para los métodos de las clases derivadas y para todos sus clientes.
class Base
{ private:
// Miembros declarados en la sección privada: accesibles sólo para miembros de esta clase
protected:
/* Miembros declarados en la sección protegida: accesibles sólo para miembros de esta
clase y de sus derivadas */
public:
// Miembros declarados en la sección pública: accesibles para todos
};
Para declarar una clase derivada de una clase previamente definida se utiliza la siguiente sintaxis:
class Base
{ // Declaración de atributos y métodos de la clase Base
};
// Relación de herencia pública entre las clases Base y Derivada
class Derivada : public Base
{ // Declaración de atributos y métodos de la clase Derivada
};
Con la palabra reservada public en el encabezado de la declaración de la clase “Derivada” se hace referencia a que dicha clase hereda los atributos y métodos de la clase “Base”.
La declaración del constructor de la clase “Derivada” debe incluir un llamado al constructor de la clase “Base”.
Para ello se utiliza la siguiente sintaxis:
Derivada :: Derivada (parámetros) : Base (parámetros propios de la clase Base)
{ // Cuerpo del constructor de la clase Derivada
}
Cuando se declara un objeto del tipo de la clase derivada se invoca al constructor de ésta. De este constructor lo primero que se ejecuta es la llamada al constructor de la clase base, y posteriormente se ejecutan sus propias instrucciones.
En cuanto a los parámetros, al invocar al constructor de la clase base se le deben proporcionar los parámetros que necesita para asignar valores a los atributos propios de la clase base y que la clase derivada hereda. En el cuerpo de la clase derivada se harán las asignaciones correspondientes a los atributos propios de esta clase.
3.2 Herencia.
La 'herencia' es una de las piedras angulares de la POO ya que ésta permite la creación de clasificaciones jerárquicas. Con la herencia, es posible crear una clase general que defina tratos comunes a una serie de elementos relacionados. Esta clase podría luego ser heredada por otras clases más específicas, cada una agregando solo aquellas cosas que son únicas para la clase 'heredera'.
En terminología estándar C++, una clase que es heredada es referida como la clase 'base'. La clase que efectúa la herencia es llamada la clase 'derivada'. Además, una clase derivada puede ser usada como una clase base por otra clase derivada. De esta manera, una jerarquía multicapa de clases puede ser lograda.
Evidentemente, la clase base y la clase derivada tienen código y datos comunes, de modo que si se crea la clase derivada de modo independiente, se duplicaría mucho de lo que ya se ha escrito para la clase base.
C++ soporta el mecanismo de derivación que permite crear clases derivadas, de modo que la nueva clase heredan todos los datos miembro que pertenecen a la clase ya existente.
La declaración de derivación de clases debe incluir el nombre de la clase base de la que se deriva y el especificador de acceso que indica el tipo de herencia (pública, privada y protegida). La primera línea de cada declaración debe incluir la sintaxis siguiente:
class <nombre de clase derivada> : <tipo de herencia> <nombre de clase base>
Ejemplo 1
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;
class integracion
{
protected:
float a,b;
int n,op;
public:
integracion ()
{a=b=n=0;
}
float f(float n)
{
float x;
x= pow(n,2)+(6*n)-(3);
return x;
}
void introducir_limites()
{
cout<<"Introduzca el limite de integracion A:"<<endl;
cin>>a;
cout<<"Introduzca el limite de integracion B:"<<endl;
cin>>b;
cout<<"Introduzca el numero de segmentos:"<<endl;
cin>>n;
}
void leer()
{
cout<<"Introduzca el limite de integracion A:"<<endl;
cin>>a;
cout<<"Introduzca el limite de integracion B:"<<endl;
cin>>b;
}
};
class trapecio:public integracion
{
public:
trapecio():integracion()
{}
float m_trapecio()
{
float i,sum=0, cont=a;
float h=(b-a)/n;
for(int i=1;i<=n-1;i++)
{
cont+=h;
sum+=f(cont);
}
i=(b-a)*(f(a)+2*(sum)+f(b))/(2*n);
return i;
}
void imprime_integral()
{
cout<<"Aproximacion a la integral por trapecio multiple con n= "<<n<<" = "<<m_trapecio()<<endl;
}
};
class calcu3:public integracion
{
public:
calcu3():integracion()
{}
float integ3(int a, int b)
{
float y,y1,y2,y3,i,h,j;
h=(b-a);
h=h/3;
y=f(a);
j=a+h;
y1=f(j);
j+=h;
y2=f(j);
y3=f(b);
i=((h*3)/8)*((y+(3*y1)+(3*y2)+y3));
return i;
}
void imprime3()
{
cout<<"El valor de aproximacion mediante simpson 3/8 es :"<<integ3(a,b)<<endl;
}
};
class calcu1:public integracion
{
public:
calcu1(): integracion()
{}
float integ1(int a, int b)
{
float i;
i=(b-a)*((f(a)+(4*f((a+b)/2))+f(b))/4);
return i;
}
void imprime1()
{
cout<<"El valor de aproximacion mediante simpson 1/3 es "<<integ1(a,b)<<endl;
}
};
int main(int argc, char *argv[])
{
int op;
trapecio objtrap;
calcu1 objcalc1;
cout<<"Programa para resolver la ecuacion x^2+6x-3 por tres metodos, elija uno"<<endl;
cout<<"1 Metodo trapecio"<<endl;
cout<<"2 Simpson 1/3"<<endl;
cout<<"3 Simpson 3/8"<<endl;
cin>>op;
switch(op)
{
case 1:
objtrap.introducir_limites();
objtrap.imprime_integral();
break;
case 2:
objcalc1.leer();
objcalc1.imprime1();
break;
case 3:
calcu3 objcalc3;
objcalc3.leer();
objcalc3.imprime3();
break;
}
system("PAUSE");
return EXIT_SUCCESS;
}
En terminología estándar C++, una clase que es heredada es referida como la clase 'base'. La clase que efectúa la herencia es llamada la clase 'derivada'. Además, una clase derivada puede ser usada como una clase base por otra clase derivada. De esta manera, una jerarquía multicapa de clases puede ser lograda.
Evidentemente, la clase base y la clase derivada tienen código y datos comunes, de modo que si se crea la clase derivada de modo independiente, se duplicaría mucho de lo que ya se ha escrito para la clase base.
C++ soporta el mecanismo de derivación que permite crear clases derivadas, de modo que la nueva clase heredan todos los datos miembro que pertenecen a la clase ya existente.
La declaración de derivación de clases debe incluir el nombre de la clase base de la que se deriva y el especificador de acceso que indica el tipo de herencia (pública, privada y protegida). La primera línea de cada declaración debe incluir la sintaxis siguiente:
class <nombre de clase derivada> : <tipo de herencia> <nombre de clase base>
Ejemplo 1
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;
class integracion
{
protected:
float a,b;
int n,op;
public:
integracion ()
{a=b=n=0;
}
float f(float n)
{
float x;
x= pow(n,2)+(6*n)-(3);
return x;
}
void introducir_limites()
{
cout<<"Introduzca el limite de integracion A:"<<endl;
cin>>a;
cout<<"Introduzca el limite de integracion B:"<<endl;
cin>>b;
cout<<"Introduzca el numero de segmentos:"<<endl;
cin>>n;
}
void leer()
{
cout<<"Introduzca el limite de integracion A:"<<endl;
cin>>a;
cout<<"Introduzca el limite de integracion B:"<<endl;
cin>>b;
}
};
class trapecio:public integracion
{
public:
trapecio():integracion()
{}
float m_trapecio()
{
float i,sum=0, cont=a;
float h=(b-a)/n;
for(int i=1;i<=n-1;i++)
{
cont+=h;
sum+=f(cont);
}
i=(b-a)*(f(a)+2*(sum)+f(b))/(2*n);
return i;
}
void imprime_integral()
{
cout<<"Aproximacion a la integral por trapecio multiple con n= "<<n<<" = "<<m_trapecio()<<endl;
}
};
class calcu3:public integracion
{
public:
calcu3():integracion()
{}
float integ3(int a, int b)
{
float y,y1,y2,y3,i,h,j;
h=(b-a);
h=h/3;
y=f(a);
j=a+h;
y1=f(j);
j+=h;
y2=f(j);
y3=f(b);
i=((h*3)/8)*((y+(3*y1)+(3*y2)+y3));
return i;
}
void imprime3()
{
cout<<"El valor de aproximacion mediante simpson 3/8 es :"<<integ3(a,b)<<endl;
}
};
class calcu1:public integracion
{
public:
calcu1(): integracion()
{}
float integ1(int a, int b)
{
float i;
i=(b-a)*((f(a)+(4*f((a+b)/2))+f(b))/4);
return i;
}
void imprime1()
{
cout<<"El valor de aproximacion mediante simpson 1/3 es "<<integ1(a,b)<<endl;
}
};
int main(int argc, char *argv[])
{
int op;
trapecio objtrap;
calcu1 objcalc1;
cout<<"Programa para resolver la ecuacion x^2+6x-3 por tres metodos, elija uno"<<endl;
cout<<"1 Metodo trapecio"<<endl;
cout<<"2 Simpson 1/3"<<endl;
cout<<"3 Simpson 3/8"<<endl;
cin>>op;
switch(op)
{
case 1:
objtrap.introducir_limites();
objtrap.imprime_integral();
break;
case 2:
objcalc1.leer();
objcalc1.imprime1();
break;
case 3:
calcu3 objcalc3;
objcalc3.leer();
objcalc3.imprime3();
break;
}
system("PAUSE");
return EXIT_SUCCESS;
}
3.1 Polimorfismo
El término polimorfismo hace referencia a la capacidad de adoptar diversas formas, por lo tanto un objeto polimorfo es aque que tendra la capacidad de tener diversos aspectos.
El polimorfismo permite que un mismo metodo adquiera distintos contenidos declarando funciones o métodos virtuales en la clase base y otras formas de los mismos en las clases derivadas.
Por medio del polimorfismo se puede definir un solo metodo para objetos diferentes. En c++ el polimorfismo se define a través de funciones virtuales.
FUNCIONES VIRTUALES
Las funciones o metodos virtuales se usan en las clases base para indicar que puede haber multiples formas de ellos y las clases derivadas. Para indicar que un metodo es virtual, se hace uso de la palabra reservada 'virtual'.
Sintaxis:
Virtual<tipo> (nombre_función)(lista parametros)
Si la funcion no se define exactamente con el mismo tipo de retorno y numero y tipo de parametros de la clase base, no se conseidera como la misma funcion, si no como una funcion superpuesta.
//Ejercicio 1
class persona
{
protected:
char nombre[30];
public:
persona(char*num);
virtual void vernombre();
};
persona::persona (char*nom)
{strcpy (nombre,nom);}
void persona::vernombre()
{
cout<<"Nombre "<<nombre<<endl;
}
class empleado:public persona
{
public:
empleado(char*nom):persona(nom){};
void vernombre();
};
void empleado::vernombre()
{
cout<<"Empleado "<<nombre<<endl;
}
class estudiante:public persona
{
public:
estudiante (char*nom):persona(nom){};
void vernombre();
};
void estudiante::vernombre()
{
cout<<"Estudiante "<<nombre<<endl;
}
void usapolimorfismo()
{
persona*estud=new estudiante ("John");
persona*emp=new empleado ("Carlos");
estud->vernombre();
emp->vernombre();
system ("PAUSE");
}
int main ()
{
usapolimorfismo();
return 0;
}
//Ejercicio 2
class volumen
{
protected: char nombre[30];
public: volumen(char*n){strcpy(nombre, n);}
virtual void imprime(){cout<<"Volumen: "<<nombre<<endl;}
};
class libro:public volumen
{
protected:int AnioED;
public:
libro(char*n, int an):volumen(n){AnioED=an;};
void imprime()
{
cout<<"Libro: "<<nombre<<endl;
cout<<"Año edicion: "<<AnioED<<endl;
}
};
class revista:public volumen
{
protected: int numRev;
public: revista(char*n, int num):volumen(n){numRev=num;};
void imprime()
{
cout<<"Revista: "<<nombre<<endl;
cout<<"Numero de Revista: "<<numRev<<endl;
}
};
void UsaPolimorfismo()
{
volumen*lib= new libro("Poli ", 2005);
volumen*rev= new revista("Morfismo ",1);
lib->imprime();
rev->imprime();
system("PAUSE");
}
int main(){
UsaPolimorfismo();
return 0;
El polimorfismo permite que un mismo metodo adquiera distintos contenidos declarando funciones o métodos virtuales en la clase base y otras formas de los mismos en las clases derivadas.
Por medio del polimorfismo se puede definir un solo metodo para objetos diferentes. En c++ el polimorfismo se define a través de funciones virtuales.
FUNCIONES VIRTUALES
Las funciones o metodos virtuales se usan en las clases base para indicar que puede haber multiples formas de ellos y las clases derivadas. Para indicar que un metodo es virtual, se hace uso de la palabra reservada 'virtual'.
Sintaxis:
Virtual<tipo> (nombre_función)(lista parametros)
Si la funcion no se define exactamente con el mismo tipo de retorno y numero y tipo de parametros de la clase base, no se conseidera como la misma funcion, si no como una funcion superpuesta.
//Ejercicio 1
class persona
{
protected:
char nombre[30];
public:
persona(char*num);
virtual void vernombre();
};
persona::persona (char*nom)
{strcpy (nombre,nom);}
void persona::vernombre()
{
cout<<"Nombre "<<nombre<<endl;
}
class empleado:public persona
{
public:
empleado(char*nom):persona(nom){};
void vernombre();
};
void empleado::vernombre()
{
cout<<"Empleado "<<nombre<<endl;
}
class estudiante:public persona
{
public:
estudiante (char*nom):persona(nom){};
void vernombre();
};
void estudiante::vernombre()
{
cout<<"Estudiante "<<nombre<<endl;
}
void usapolimorfismo()
{
persona*estud=new estudiante ("John");
persona*emp=new empleado ("Carlos");
estud->vernombre();
emp->vernombre();
system ("PAUSE");
}
int main ()
{
usapolimorfismo();
return 0;
}
//Ejercicio 2
class volumen
{
protected: char nombre[30];
public: volumen(char*n){strcpy(nombre, n);}
virtual void imprime(){cout<<"Volumen: "<<nombre<<endl;}
};
class libro:public volumen
{
protected:int AnioED;
public:
libro(char*n, int an):volumen(n){AnioED=an;};
void imprime()
{
cout<<"Libro: "<<nombre<<endl;
cout<<"Año edicion: "<<AnioED<<endl;
}
};
class revista:public volumen
{
protected: int numRev;
public: revista(char*n, int num):volumen(n){numRev=num;};
void imprime()
{
cout<<"Revista: "<<nombre<<endl;
cout<<"Numero de Revista: "<<numRev<<endl;
}
};
void UsaPolimorfismo()
{
volumen*lib= new libro("Poli ", 2005);
volumen*rev= new revista("Morfismo ",1);
lib->imprime();
rev->imprime();
system("PAUSE");
}
int main(){
UsaPolimorfismo();
return 0;
2.1 Construcción de Clases y Objetos
Definición de una clase
Una clase está formada por:
* Atributos
* Métodos
Al definir una clase se establecen tres grados de seguridad para sus miembros:
* Privados: Se utiliza para definir los atributos, en casos muy especiales algunos métodos de la clase. Los miembros definidos en esta sección solo pueden acceder por miembros de la misma clase. La privacidad permite garantizar la protección de los atributos y métodos definidos en esta sección.
* Protegido: En esta sección se definen los atributos y métodos que se comparten con las clases derivadas. Es decir los miembros de la clase definidos en esta sección solo pueden ser accedidos por miembros de la misma clase o sus clases derivadas.
* Público: En esta sección se definen los atributos y métodos que están disponibles para cualquier clase (ya sea derivada o externa)
Sintaxis.
Class Nombre
{
private:
//Atributos y métodos de la clase
protected:
//Atributos y métodos de la clase
public:
//Atributos y métodos de la clase
};
Ejemplo.
class Persona
{
private: //Atributos
char Nombre[60], Domicilio[60];
int Edad;
public: //Métodos
void Actualiza_Domicilio (char NuevoDom[]);
};
Una clase es un conjunto de objetos que comparten una estructura y comportamiento comunes. Las clases actúan como intermediarias entre una abstracción y los clientes que pretenden utilizar la abstracción. De esta forma, la clase muestra:
* Visión externa de comportamiento (interface), que enfatiza la abstracción escondiendo su estructura y secretos de comportamiento.
* Visión interna (implementación), que abarca el código que se ofrece en la interface de la clase.
Relaciones entre clases: Representan tipos de compartición entre clases, o relaciones semánticas.
* Asociación. Indica relaciones de mandato bidireccionales (Punteros ocultos en C++). Conlleva dependencia semántica y no establece una dirección de dependencia. Tienen cordialidad.
* Herencia. Por esta relación una clase (subclase) comparte la estructura y/o comportamiento definidos en una (herencia simple) o más (herencia múltiple) clases, llamadas superclases.
* Agregación. Representa una relación del tipo "tener un" entre clases. Cuando la clase contenida no existe independientemente de la clase que la contiene se denomina agregación por valor y además implica contenido físico, mientras que si existe independientemente y se accede a ella indirectamente, es agregación por referencia.
* Uso. Es un refinamiento de la asociación donde se especifica cual es el cliente y cual el servidor de ciertos servicios, permitiendo a los clientes acceder sólo a las interfaces públicas de los servidores, ofreciendo mayor encapsulación de la información.
* Ejemplificación. Se usa en lenguajes que soportan generosidad (declaración de clases parametrizadas y argumentos tipo témplate). Representa las relaciones entre las clases parametrizadas, que admiten parámetros formales, y las clases obtenidas cuando se concretan estos parámetros formales, ejemplificados o inicializados con un ejemplo.
Objetos
Un objeto es una cosa tangible, algo a que se puede aprehender intelectualmente o algo hacia lo que se puede dirigir una acción o pensamiento. Un objeto representa un ítem individual e identificable, o una entidad real o abstracta, con un papel definido en el dominio del problema. Un objeto tiene:
1. Estado
2. Comportamiento
3. Identidad
La estructura y el comportamiento de objetos similares se definen en sus clases comunes. El término objeto e instancia de una clase son intercambiables.
El estado de un objeto abarca todas las propiedades del objeto, y los valores actuales de cada una de esas propiedades. Las propiedades de los objetos suelen ser estáticas, mientras los valores que toman estas propiedades cambian con el tiempo.
El hecho de que los objetos tengan estado implica que ocupan un espacio, ya sea en el mundo físico, o ya sea en la memoria del ordenador. El estado de un objeto está influido por la historia del objeto.
No deben confundirse los objetos, que existen en el tiempo, son mutables, tienen estado, pueden ser creados, destruidos y compartidos..., con los valores (los asignados a una variable, por ejemplo) que son cantidades con las propiedades de ser atemporales, inmutables. El estado de un objeto representa el efecto acumulado de su comportamiento.
Identidad es la propiedad de un objeto que lo lleva a distinguirse de otros.
Comportamiento es como un objeto actúa y reacciona, en términos de sus cambios de estado y de los mensajes que intercambia. Un objeto puede realizar cinco tipos de operaciones sobre otro, con el propósito de provocar una reacción:
* Modificador: altera el estado de un objeto.
* Selector: accede al estado de un objeto, sin alterarlo.
* Iterado: permite a todas las partes de un objeto ser accedidas en un orden.
* Constructor: crea un objeto y/o inicializa su estado.
* Destructor: libera el estado de un objeto y/o destruye el objeto.
C++ soporta, además de las operaciones, subprogramas libres. En la terminología de C++ las operaciones que un cliente puede realizar sobre un objeto se declaran como función miembro.
Estructuras.
Es una colección de una o más variables agrupadas bajo un mismo nombre para facilitar su manejo, cada uno de los cuales se conoce como un elemento o miembro de la estructura.
Una estructura puede contener cualquiera de los tipos de dato de c (float, double, int, char, long, etc.) incluyendo arreglos y otras estructuras.
Sintaxis.
La forma general de una definición de estructura es:
struct Etiqueta
{
tipo nombre_variable1;
tipo nombre_variable2;
tipo nombre_variable3;
……
}variables_de_estructura;
Ejemplo.
struct dir //Etiqueta de la clase
{
char nombre[30];
char calle[40];
char ciudad[20];
char estado[30];
unsigned long int codigo;
}info_dir,binfo,cinfo; //Instancias o variables tipo dir
Las estructuras de datos se emplean con el objetivo principal de organizar los datos contenidos dentro de la memoria del ordenador. Así, nuestra primera experiencia con estructuras comienza desde el momento mismo en que usamos en nuestros programas variables de tipos primitivos (char, short, int, float, etc).
Ejercicios.
NOTACION APUNTADOR
#include<stdlib.h>
#include <iostream>
#define MAX 5
using namespace std;
int main()
{
int calif[MAX]={98,87,82,64,70};
int *g_ptr;
g_ptr=&calif[0];
for(int i=0;i<MAX;i++)
{
cout<<"Elemento "<<i<<"= "<<*(g_ptr+i)<<endl; //Notacion apuntador
}
system("pause");
return 0;
}
NOTACION ARREGLO
#include<stdlib.h>
#include <iostream>
#define MAX 5
using namespace std;
int main()
{
int calif[MAX]={98,87,82,64,70};
int *g_ptr;
g_ptr=&calif[0];
for(int i=0;i<MAX;i++)
{
cout<<"Elemento "<<i<<"= "<<g_ptr[i]<<endl; //Notacion arreglo
}
system("pause");
return 0;
}
NOTACION ARREGLO
#include <iostream>
#include <stdlib.h>
using namespace std;
int main ()
{
int numcalif,i;
cout<<"Introduzca el numero de califiaciones"<< endl;
cin>>numcalif;
int *ptr_calif;
ptr_calif = new int [numcalif];
for (i=0;i<numcalif;i++)
{
cout<<"Introdusca calificacion"<<endl;
cin>>ptr_calif[i];
}
cout<<"Se creo un arreglo para :"<<numcalif<<"numeros enteros"<<endl;
cout<<"Los valores almacenados en el arreglo son:"<<endl;
for (i=0;i<numcalif;i++)
{
cout<<ptr_calif[i]<<endl;
}
delete[] ptr_calif;
system("pause");
return 0;
}
MATRIZ ESTATICA
#include <iostream>
#include <stdlib.h>
#define FIL 3
#define COL 3
using namespace std;
{
Int Matriz A[FIL][COL]={3,6,1,7,9,-6,4,0,8};
for(int i=0;i<FIL;i++) //filas
{
for(int j=0;j<COL;j++) //columnas
{
Cout<<Matriz A[i][j]<<”\t”;
}
Cout<<endl;
}
system(“pause”);
return 0;
}
ESTRUCUTRAS DENTRO DE MAIN
*
#include <conio.h>
#include <iostream>
using namespace std;
int main()
{
struct
{
int mes;
int dia;
int anio;
}nacimiento; //Etiqueta
nacimiento.mes=12;
nacimiento.dia=28;
nacimiento.anio=86;
cout<<"Mi fecha de nacimiento es: "<<nacimiento.mes<<"/"<<nacimiento.dia<<"/"<<nacimiento.anio<<endl;
getch();
return 0;
}
*
#include <conio.h>
#include <iostream>
using namespace std;
struct nacimiento
{
int mes;
int dia;
int anio;
};
int main()
{
nacimiento fecha1; //Opcion 1
fecha1.mes=12;
fecha1.dia=28;
fecha1.anio=86;
cout<<"Mi fecha de nacimiento es: "<<fecha1.mes<<"/"<<fecha1.dia<<"/"<<fecha1.anio<<endl;
getch();
return 0;
}
*
#include <conio.h>
#include <iostream>
using namespace std;
const int NUMREG=5; //Numero maximo de registro
struct Reg_pago
{
int id;
char nombre[20];
double tarifa;
};
int main()
{
Reg_pago empleado[NUMREG]={{1,"Carlos",7.28},
{2,"Esther",6.80},
{3,"Antonio",10.50},
{4,"Eduardo",11.20},
{5,"Ana",12.30}};
cout<<"Empleados del mes: "<<endl;
cout<<"No."<<"/"<<"Nombre"<<"/"<<"Tarifa"<<endl;
for(int i=0;i<NUMREG;i++)
{
cout<<empleado[i].id<<"/"<<empleado[i].nombre<<"/"<<empleado[i].tarifa<<endl;
}
getch();
return 0;
}
Segunda opción.
#include <conio.h>
#include <iostream>
using namespace std;
struct nacimiento
{
int dia,mes,anio;
}fecha2;
int main()
{
fecha2.dia=13;
fecha2.mes=6;
fecha2.anio=2015;
cout<<"Fecha: "<<fecha2.mes<<"/"<<fecha2.dia<<"/"<<fecha2.anio<<endl;
getch();
return 0;
}
*
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
struct empleado
{
char nombre[30];
int edad;
float salario;
float horas_t;
empleado(char * nomb, int e, float s,float h)//constructor
{
strcpy(nombre,nomb);
edad=e;
salario=s;
horas_t=h;
}
void salida()
{
cout<<"NOMBRE---->"<<nombre<<endl;
cout<<"EDAD------>"<<edad<<endl;
cout<<"SALARIO--->"<<salario<<endl;
cout<<"HORAS -->"<<horas_t<<endl<<endl;
if (horas_t>8)
cout<<"Cubriendo horas extras"<<endl;
else
cout<<"Cubriendo horario regular"<<endl;
}
};
int main()
{
empleado empleado1("Juan",25,1000,5);
empleado1.salida();
system("pause");
return 0;
}
Una clase está formada por:
* Atributos
* Métodos
Al definir una clase se establecen tres grados de seguridad para sus miembros:
* Privados: Se utiliza para definir los atributos, en casos muy especiales algunos métodos de la clase. Los miembros definidos en esta sección solo pueden acceder por miembros de la misma clase. La privacidad permite garantizar la protección de los atributos y métodos definidos en esta sección.
* Protegido: En esta sección se definen los atributos y métodos que se comparten con las clases derivadas. Es decir los miembros de la clase definidos en esta sección solo pueden ser accedidos por miembros de la misma clase o sus clases derivadas.
* Público: En esta sección se definen los atributos y métodos que están disponibles para cualquier clase (ya sea derivada o externa)
Sintaxis.
Class Nombre
{
private:
//Atributos y métodos de la clase
protected:
//Atributos y métodos de la clase
public:
//Atributos y métodos de la clase
};
Ejemplo.
class Persona
{
private: //Atributos
char Nombre[60], Domicilio[60];
int Edad;
public: //Métodos
void Actualiza_Domicilio (char NuevoDom[]);
};
Una clase es un conjunto de objetos que comparten una estructura y comportamiento comunes. Las clases actúan como intermediarias entre una abstracción y los clientes que pretenden utilizar la abstracción. De esta forma, la clase muestra:
* Visión externa de comportamiento (interface), que enfatiza la abstracción escondiendo su estructura y secretos de comportamiento.
* Visión interna (implementación), que abarca el código que se ofrece en la interface de la clase.
Relaciones entre clases: Representan tipos de compartición entre clases, o relaciones semánticas.
* Asociación. Indica relaciones de mandato bidireccionales (Punteros ocultos en C++). Conlleva dependencia semántica y no establece una dirección de dependencia. Tienen cordialidad.
* Herencia. Por esta relación una clase (subclase) comparte la estructura y/o comportamiento definidos en una (herencia simple) o más (herencia múltiple) clases, llamadas superclases.
* Agregación. Representa una relación del tipo "tener un" entre clases. Cuando la clase contenida no existe independientemente de la clase que la contiene se denomina agregación por valor y además implica contenido físico, mientras que si existe independientemente y se accede a ella indirectamente, es agregación por referencia.
* Uso. Es un refinamiento de la asociación donde se especifica cual es el cliente y cual el servidor de ciertos servicios, permitiendo a los clientes acceder sólo a las interfaces públicas de los servidores, ofreciendo mayor encapsulación de la información.
* Ejemplificación. Se usa en lenguajes que soportan generosidad (declaración de clases parametrizadas y argumentos tipo témplate). Representa las relaciones entre las clases parametrizadas, que admiten parámetros formales, y las clases obtenidas cuando se concretan estos parámetros formales, ejemplificados o inicializados con un ejemplo.
Objetos
Un objeto es una cosa tangible, algo a que se puede aprehender intelectualmente o algo hacia lo que se puede dirigir una acción o pensamiento. Un objeto representa un ítem individual e identificable, o una entidad real o abstracta, con un papel definido en el dominio del problema. Un objeto tiene:
1. Estado
2. Comportamiento
3. Identidad
La estructura y el comportamiento de objetos similares se definen en sus clases comunes. El término objeto e instancia de una clase son intercambiables.
El estado de un objeto abarca todas las propiedades del objeto, y los valores actuales de cada una de esas propiedades. Las propiedades de los objetos suelen ser estáticas, mientras los valores que toman estas propiedades cambian con el tiempo.
El hecho de que los objetos tengan estado implica que ocupan un espacio, ya sea en el mundo físico, o ya sea en la memoria del ordenador. El estado de un objeto está influido por la historia del objeto.
No deben confundirse los objetos, que existen en el tiempo, son mutables, tienen estado, pueden ser creados, destruidos y compartidos..., con los valores (los asignados a una variable, por ejemplo) que son cantidades con las propiedades de ser atemporales, inmutables. El estado de un objeto representa el efecto acumulado de su comportamiento.
Identidad es la propiedad de un objeto que lo lleva a distinguirse de otros.
Comportamiento es como un objeto actúa y reacciona, en términos de sus cambios de estado y de los mensajes que intercambia. Un objeto puede realizar cinco tipos de operaciones sobre otro, con el propósito de provocar una reacción:
* Modificador: altera el estado de un objeto.
* Selector: accede al estado de un objeto, sin alterarlo.
* Iterado: permite a todas las partes de un objeto ser accedidas en un orden.
* Constructor: crea un objeto y/o inicializa su estado.
* Destructor: libera el estado de un objeto y/o destruye el objeto.
C++ soporta, además de las operaciones, subprogramas libres. En la terminología de C++ las operaciones que un cliente puede realizar sobre un objeto se declaran como función miembro.
Estructuras.
Es una colección de una o más variables agrupadas bajo un mismo nombre para facilitar su manejo, cada uno de los cuales se conoce como un elemento o miembro de la estructura.
Una estructura puede contener cualquiera de los tipos de dato de c (float, double, int, char, long, etc.) incluyendo arreglos y otras estructuras.
Sintaxis.
La forma general de una definición de estructura es:
struct Etiqueta
{
tipo nombre_variable1;
tipo nombre_variable2;
tipo nombre_variable3;
……
}variables_de_estructura;
Ejemplo.
struct dir //Etiqueta de la clase
{
char nombre[30];
char calle[40];
char ciudad[20];
char estado[30];
unsigned long int codigo;
}info_dir,binfo,cinfo; //Instancias o variables tipo dir
Las estructuras de datos se emplean con el objetivo principal de organizar los datos contenidos dentro de la memoria del ordenador. Así, nuestra primera experiencia con estructuras comienza desde el momento mismo en que usamos en nuestros programas variables de tipos primitivos (char, short, int, float, etc).
Ejercicios.
NOTACION APUNTADOR
#include<stdlib.h>
#include <iostream>
#define MAX 5
using namespace std;
int main()
{
int calif[MAX]={98,87,82,64,70};
int *g_ptr;
g_ptr=&calif[0];
for(int i=0;i<MAX;i++)
{
cout<<"Elemento "<<i<<"= "<<*(g_ptr+i)<<endl; //Notacion apuntador
}
system("pause");
return 0;
}
NOTACION ARREGLO
#include<stdlib.h>
#include <iostream>
#define MAX 5
using namespace std;
int main()
{
int calif[MAX]={98,87,82,64,70};
int *g_ptr;
g_ptr=&calif[0];
for(int i=0;i<MAX;i++)
{
cout<<"Elemento "<<i<<"= "<<g_ptr[i]<<endl; //Notacion arreglo
}
system("pause");
return 0;
}
NOTACION ARREGLO
#include <iostream>
#include <stdlib.h>
using namespace std;
int main ()
{
int numcalif,i;
cout<<"Introduzca el numero de califiaciones"<< endl;
cin>>numcalif;
int *ptr_calif;
ptr_calif = new int [numcalif];
for (i=0;i<numcalif;i++)
{
cout<<"Introdusca calificacion"<<endl;
cin>>ptr_calif[i];
}
cout<<"Se creo un arreglo para :"<<numcalif<<"numeros enteros"<<endl;
cout<<"Los valores almacenados en el arreglo son:"<<endl;
for (i=0;i<numcalif;i++)
{
cout<<ptr_calif[i]<<endl;
}
delete[] ptr_calif;
system("pause");
return 0;
}
MATRIZ ESTATICA
#include <iostream>
#include <stdlib.h>
#define FIL 3
#define COL 3
using namespace std;
{
Int Matriz A[FIL][COL]={3,6,1,7,9,-6,4,0,8};
for(int i=0;i<FIL;i++) //filas
{
for(int j=0;j<COL;j++) //columnas
{
Cout<<Matriz A[i][j]<<”\t”;
}
Cout<<endl;
}
system(“pause”);
return 0;
}
ESTRUCUTRAS DENTRO DE MAIN
*
#include <conio.h>
#include <iostream>
using namespace std;
int main()
{
struct
{
int mes;
int dia;
int anio;
}nacimiento; //Etiqueta
nacimiento.mes=12;
nacimiento.dia=28;
nacimiento.anio=86;
cout<<"Mi fecha de nacimiento es: "<<nacimiento.mes<<"/"<<nacimiento.dia<<"/"<<nacimiento.anio<<endl;
getch();
return 0;
}
*
#include <conio.h>
#include <iostream>
using namespace std;
struct nacimiento
{
int mes;
int dia;
int anio;
};
int main()
{
nacimiento fecha1; //Opcion 1
fecha1.mes=12;
fecha1.dia=28;
fecha1.anio=86;
cout<<"Mi fecha de nacimiento es: "<<fecha1.mes<<"/"<<fecha1.dia<<"/"<<fecha1.anio<<endl;
getch();
return 0;
}
*
#include <conio.h>
#include <iostream>
using namespace std;
const int NUMREG=5; //Numero maximo de registro
struct Reg_pago
{
int id;
char nombre[20];
double tarifa;
};
int main()
{
Reg_pago empleado[NUMREG]={{1,"Carlos",7.28},
{2,"Esther",6.80},
{3,"Antonio",10.50},
{4,"Eduardo",11.20},
{5,"Ana",12.30}};
cout<<"Empleados del mes: "<<endl;
cout<<"No."<<"/"<<"Nombre"<<"/"<<"Tarifa"<<endl;
for(int i=0;i<NUMREG;i++)
{
cout<<empleado[i].id<<"/"<<empleado[i].nombre<<"/"<<empleado[i].tarifa<<endl;
}
getch();
return 0;
}
Segunda opción.
#include <conio.h>
#include <iostream>
using namespace std;
struct nacimiento
{
int dia,mes,anio;
}fecha2;
int main()
{
fecha2.dia=13;
fecha2.mes=6;
fecha2.anio=2015;
cout<<"Fecha: "<<fecha2.mes<<"/"<<fecha2.dia<<"/"<<fecha2.anio<<endl;
getch();
return 0;
}
*
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
struct empleado
{
char nombre[30];
int edad;
float salario;
float horas_t;
empleado(char * nomb, int e, float s,float h)//constructor
{
strcpy(nombre,nomb);
edad=e;
salario=s;
horas_t=h;
}
void salida()
{
cout<<"NOMBRE---->"<<nombre<<endl;
cout<<"EDAD------>"<<edad<<endl;
cout<<"SALARIO--->"<<salario<<endl;
cout<<"HORAS -->"<<horas_t<<endl<<endl;
if (horas_t>8)
cout<<"Cubriendo horas extras"<<endl;
else
cout<<"Cubriendo horario regular"<<endl;
}
};
int main()
{
empleado empleado1("Juan",25,1000,5);
empleado1.salida();
system("pause");
return 0;
}
1.4 El papel de las clase y objetos
Durante el análisis y las primeras etapas del diseño, el desarrollador tiene dos tareas principales:
* Identificar las clases y objetos que forman el vocabulario del dominio del problema.
* Idear las estructuras por las que conjuntos de objetos trabajan juntos para lograr los comportamientos que satisfacen los requerimientos del problema.
En conjunto, se llama a esas clases y objetos las abstracciones clave del problema, y se denomina a esas estructuras cooperativas los mecanismos de la implantación. Durante estas fases del desarrollo, el interés principal del desarrollo debe estar en la vista externa de estas abstracciones clave y mecanismos.
Esta vista representa el marco de referencia lógico del sistema y, por tanto, abarca la estruc tura de clases y la estructura de objetos del mismo. En las etapas finales del diseño y entrando ya en la implantación, la tarea del desarrollador cambia: el centro de atención está en la vista interna de estas abstracciones clave y mecanismos, involucrando a su representación física. Pueden expresarse estas decisiones de diseño como parte de la arquitectura de módulos y la arquitectura de procesos del sistema.
La experiencia de algunos analistas nos lleva a aplicar en primer lugar el criterio orientado a objetos porque esta aproximación es mejor a la hora de servir de ayuda para organizar la complejidad innata de los sistemas de software, al igual que ha servido de ayuda para describir la complejidad organizada de sistemas complejos tan diversos como los computadores, plantas, galaxias o grandes instituciones sociales.
Los sistemas orientados a objetos son también más resistentes al cambio y por lo tanto están mejor preparados para evolucionar en el tiempo, porque su diseño esta basado en formas intermedias estables.
El modelo de objetos ha influido incluso en las fases iniciales del ciclo de vida del desarrollo del software. El análisis orientado a objetos (AOO) enfatiza la construcción de modelos del mundo real utilizando una visión del mundo orientado a objetos:
El análisis orientado a objetos es un método de análisis que examina los requisitos desde la perspectiva de las clases y objetos que se encuentran en el vocabulario del dominio del problema.
Básicamente los productos del análisis orientado a objetos sirven como modelos de los que se puede partir para un diseño orientado a objetos; los productos del diseño orientado a objetos pueden utilizarse entonces como anteproyectos para la implementación completa de unos sistemas utilizando métodos de programación orientado a objetos, de esta forma se relacionan AOO, DOO y POO.
Se insiste que se ha encontrado un gran valor en la construcción de modelos que se centran en las “cosas” que se encuentran en el espacio del problema formando lo que se ha llamado una descomposición orientada a objetos.
El diseño orientado a objetos es el método que lleva a una descomposición orientado a objetos. Ofrece un rico conjuntos de modelos que reflejan la importancia de plasmar explícitamente las jerarquías de clases y de objetos de los sistemas que diseña.
El análisis orientado a objetos (AOO) se basa en conceptos sencillos, conocidos desde la infancia y que aplicamos continuamente: objetos y atributos, él todo y las partes, clases y miembros. Puede parecer llamativo que se haya tardado tanto tiempo en aplicar estos conceptos al desarrollo de software. Posiblemente, una de las razones es el éxito de los métodos de análisis estructurados, basados en los conceptos de flujo de información, que monopolizaron el análisis de sistemas de software durante los últimos veinte años.
El AOO ofrece un enfoque nuevo para el análisis de requisitos de sistemas software. En lugar de considerar el software desde una perspectiva clásica de entrada - proceso - salida, como los métodos estructurados clásicos se basan en modelar el sistema mediante los objetos que forman parte de el y las relaciones estáticas o dinámicas entre estos objetos.
Este enfoque pretende conseguir modelos que se ajusten mejor al problema real a partir del conocimiento del llamado dominio del problema.
UN PUNTO DE VISTA:
Desde el punto de vista de los análisis antes mencionados hablamos del AOO y el AEO, podemos decir que el AOO concibe una abstracción mayor que el AEO, que modela los sistemas desde un punto de vista más próximo a su implementaron en un ordenador (entrada/proceso/salida).
La ventaja del AOO es que se basa en la utilización de objetos como abstracciones del mundo real. Esto nos permite centrarnos en los aspectos significativos del domino del problema (en las características de los objetos y las relaciones que se establecen entre ellos) y este conocimiento se convierte en la
parte fundamental del análisis del sistema software que será utilizado luego en el diseño y la implementación.
En el AOO los objetos encapsulan tanto atributos como procedimientos ( operaciones que se realizan sobre los objetos), e incorpora, además, conceptos como los polimorfismos o la herencia que facilitan la reutilización de código.
Podemos concluir entonces que el AOO puede facilitar mucho la creación de prototipos, y las técnicas de desarrollo evolutivo de software. Los objetos don inherentemente reutilizables, y se puede crear un catalogo de objetos que podemos usar en sucesivas aplicaciones. De esta forma, podemos obtener rápidamente un prototipo del sistema, que pueda ser evaluado por el cliente, a partir de los objetos analizados, diseñados e implementados en aplicaciones anteriores. Y lo que es más importante, dada la facilidad de reutilización de estos objetos, el prototipo puede ir evolucionando hacia convertirse en el sistema final, según vamos refinando los objetos de acuerdo a un proceso de especificación incremental.
VENTAJAS DEL AOO:
Dominio del problema
El paradigma OO es mas que una forma de programar. Es una forma de pensar acerca de un problema desde el punto de vista del mundo real en vez de desde el punto de vista del ordenador.
El AOO permite analizar mejor el dominio del problema, sin pensar en términos de implementar el sistema de un ordenador, permite, además, pasar directamente el dominio del problema al modelo del sistema.
Comunicación
El concepto OO es más simple y esta menos relacionado con la informática que el concepto de flujo de datos. Esto permite una mejor comunicación entre el analista y el experto en el dominio del problema.
Consistencia
Los objetos encapsulan tanto atributos como operaciones. Debido a esto, el AOO reduce la distancia entre el punto de vista de los datos y el punto de vista del proceso, dejando menos lugar a inconsistencias disparidades entre ambos modelos.
Expresión de características comunes
El paradigma lo utiliza la herencia para expresar explícitamente las características comunes de una serie de objetos estas característica comunes
quedan escondidas en otros enfoques y llevan a duplicar entidades en el análisis y código en los programas. Sin embargo, el paradigma OO pone especial énfasis en la reutilización y proporciona mecanismos efectivos que permiten reutilizar aquello que es común sin impedir por ello describir las diferencias.
Resistencia al cambio
Los cambios en los requisitos afectan notablemente a la funcionalidad de un sistema por lo que afectan mucho al software desarrollando con métodos estructurados. Sin embargo, los cambios afectan en mucha menos medida a los objetos que componen o maneja el sistema, que son mucho más estables. Las modificaciones necesarias para adaptar una aplicación basada en objetos a un cambio de requisitos suelen estar mucho más localizadas.
Reutilización
Aparte de la reutilización interna, basada en la expresión explícita de características comunes, el paradigma 00 desarrolla modelos mucho más próximos al mundo real, con lo que aumentan las posibilidades de reutilización. Es probable que en futuras aplicaciones nos encontremos con objetos iguales o similares a los de la actual.
EL MODELO DE OBJETOS
El modelo de objetos describe la estructura de los objetos de un sistema: su identidad, sus relaciones con otros objetos, sus atributos y sus operaciones. Los cambios y las transformaciones no tienen sentido a menos que haya algo que cambiar o transformar.
El modelo de objetos se representa gráficamente con diagramas de objetos y diagramas de instancias, que contienen clases de objetos e instancias respectivamente. Las clases se disponen en jerarquías que compartan una estructura de datos y un comportamiento común, y se relacionan con otras clases. Cada clase define los atributos que contiene cada uno de los objetos o instancias y las operaciones que realizan o sufren.
La tecnología orientada a objetos se apoya en sólidos fundamentos de la ingeniería, cuyos elementos reciben el nombre global de modelo de objetos. El modelo de objetos abarca principios fundamentales que los detallaremos mas adelante.
Quede claro que el diseño orientado a objetos es fundamentalmente diferente a los enfoques de diseño estructurado tradicionales; requiere un modo distinto de pensar acerca de la descomposición y produce arquitecturas software muy alejadas del dominio de la cultura del diseño estructurado.
Además, conviene mencionar que se observa que la mayoría de los programadores trabajan en un lenguaje y utilizan solo un estilo de programación. Programan bajo un paradigma apoyado por el lenguaje que usan. Frecuentemente, no se les han mostrado vías alternativas para pensar sobre un problema, y por lo tanto tiene dificultades para apreciar las ventajas de elegir un estilo, mas apropiado para el problema que tienen entre manos.
No hay un estilo de programación que sea el mejor para todo tipo de aplicaciones. Por ejemplo, la programación orientada a reglas seria la mejor para el diseño de una base de conocimiento, y la programación orientada a procedimientos seria la mas indicada parea el diseño de operaciones de calculo intensivo. Por experiencia de algunos estudiosos de la materia, el estilo orientado a objetos es él mas adecuado para él más amplio conjunto de aplicaciones; realmente, este paradigma de programación sirve con frecuencia como el marco de referencia arquitectónico en el que se emplean otros paradigmas.
Cada uno de estos estilos de programación se basa en su propio marco de referencia conceptual. Cada uno requiere una actitud mental diferente, una forma distinta de pensar en el problema. Para todas las cosas orientadas a objetos, el marco de referencia conceptual es el modelo de objetos.
FUNDAMENTOS DEL MODELO DE OBJETOS:
En realidad, el modelo de objetos ha recibido la influencia de una serie de factores, no solo de la programación orientada a objetos. El modelo de objetos a demostrado ser un concepto u unificador de en la informática. La razón de este gran atractivo es simplemente que una orientación a objetos ayuda a combatir la complejidad inherente a muchos tipos de sistemas diferentes.
El diseño orientado a objetos representa así un desarrollo evolutivo, no revolucionario; no rompe con los avances del pasado, sino que se basa en avances ya probados.
Los métodos de diseñó estructurado surgieron para guiar a los desarrolladores que intentaban construir sistemas complejos utilizando los algoritmos como bloques fundamentales para su construcción. Análogamente los métodos de diseño orientados a objetos han surgido para ayudar a los desarrolladores a explotar la potencia expresiva de los lenguajes de
programación basados en objetos y orientados a objetos, utilizando las clases como bloques básicos de construcción
Desgraciadamente, hoy en día la mayoría de los programadores han sido educados formal e informalmente solo en los principios del diseño estructurado.
En el modelo de objetos es necesario estudiar los principios fundamentales en los que se basa el análisis orientado a objetos, es decir;
· Abstracción
· Encapsulación
· Modularidad
· Jerarquía
· Concurrencia
Ninguno de estos principios es nuevo por sí mismo. Lo importante del modelo de objetos es el echo de conjugar todos estos elementos en forma sinérgica.
Al decir fundamentales, quiere decir que un modelo que carezca de cualquiera de estos elementos no estará orientado a objetos.
Otros elementos que podrían llamarse secundarios, que quiere decir, que cada uno de ellos es una parte útil del modelo de objetos, pero no esenciales son:
· Tipos
· Persistencia
A partir de los elementos antes mencionados, trataremos de mostrar, mediante una definición en primer lugar de cada uno de ellos, cual es la asociación con el sistema solar y el sistema celular, esto quiere decir que asociaremos estos elementos bases de la llamada teoría de los objetos con el macrocosmo y el microcosmo, dictando sus características fundamentales para el entendimiento claro de este. A la vez, también definiremos las desigualdades u oposiciones de estos elementos con los sistemas antes mencionados.
En otras palabras veremos como pasamos de un análisis estructurado a un análisis orientado a objetos, y viceversa. Macrocosmo v/s Microcosmo, esto incorporado al sistema de la teoría de los objetos.
* Identificar las clases y objetos que forman el vocabulario del dominio del problema.
* Idear las estructuras por las que conjuntos de objetos trabajan juntos para lograr los comportamientos que satisfacen los requerimientos del problema.
En conjunto, se llama a esas clases y objetos las abstracciones clave del problema, y se denomina a esas estructuras cooperativas los mecanismos de la implantación. Durante estas fases del desarrollo, el interés principal del desarrollo debe estar en la vista externa de estas abstracciones clave y mecanismos.
Esta vista representa el marco de referencia lógico del sistema y, por tanto, abarca la estruc tura de clases y la estructura de objetos del mismo. En las etapas finales del diseño y entrando ya en la implantación, la tarea del desarrollador cambia: el centro de atención está en la vista interna de estas abstracciones clave y mecanismos, involucrando a su representación física. Pueden expresarse estas decisiones de diseño como parte de la arquitectura de módulos y la arquitectura de procesos del sistema.
La experiencia de algunos analistas nos lleva a aplicar en primer lugar el criterio orientado a objetos porque esta aproximación es mejor a la hora de servir de ayuda para organizar la complejidad innata de los sistemas de software, al igual que ha servido de ayuda para describir la complejidad organizada de sistemas complejos tan diversos como los computadores, plantas, galaxias o grandes instituciones sociales.
Los sistemas orientados a objetos son también más resistentes al cambio y por lo tanto están mejor preparados para evolucionar en el tiempo, porque su diseño esta basado en formas intermedias estables.
El modelo de objetos ha influido incluso en las fases iniciales del ciclo de vida del desarrollo del software. El análisis orientado a objetos (AOO) enfatiza la construcción de modelos del mundo real utilizando una visión del mundo orientado a objetos:
El análisis orientado a objetos es un método de análisis que examina los requisitos desde la perspectiva de las clases y objetos que se encuentran en el vocabulario del dominio del problema.
Básicamente los productos del análisis orientado a objetos sirven como modelos de los que se puede partir para un diseño orientado a objetos; los productos del diseño orientado a objetos pueden utilizarse entonces como anteproyectos para la implementación completa de unos sistemas utilizando métodos de programación orientado a objetos, de esta forma se relacionan AOO, DOO y POO.
Se insiste que se ha encontrado un gran valor en la construcción de modelos que se centran en las “cosas” que se encuentran en el espacio del problema formando lo que se ha llamado una descomposición orientada a objetos.
El diseño orientado a objetos es el método que lleva a una descomposición orientado a objetos. Ofrece un rico conjuntos de modelos que reflejan la importancia de plasmar explícitamente las jerarquías de clases y de objetos de los sistemas que diseña.
El análisis orientado a objetos (AOO) se basa en conceptos sencillos, conocidos desde la infancia y que aplicamos continuamente: objetos y atributos, él todo y las partes, clases y miembros. Puede parecer llamativo que se haya tardado tanto tiempo en aplicar estos conceptos al desarrollo de software. Posiblemente, una de las razones es el éxito de los métodos de análisis estructurados, basados en los conceptos de flujo de información, que monopolizaron el análisis de sistemas de software durante los últimos veinte años.
El AOO ofrece un enfoque nuevo para el análisis de requisitos de sistemas software. En lugar de considerar el software desde una perspectiva clásica de entrada - proceso - salida, como los métodos estructurados clásicos se basan en modelar el sistema mediante los objetos que forman parte de el y las relaciones estáticas o dinámicas entre estos objetos.
Este enfoque pretende conseguir modelos que se ajusten mejor al problema real a partir del conocimiento del llamado dominio del problema.
UN PUNTO DE VISTA:
Desde el punto de vista de los análisis antes mencionados hablamos del AOO y el AEO, podemos decir que el AOO concibe una abstracción mayor que el AEO, que modela los sistemas desde un punto de vista más próximo a su implementaron en un ordenador (entrada/proceso/salida).
La ventaja del AOO es que se basa en la utilización de objetos como abstracciones del mundo real. Esto nos permite centrarnos en los aspectos significativos del domino del problema (en las características de los objetos y las relaciones que se establecen entre ellos) y este conocimiento se convierte en la
parte fundamental del análisis del sistema software que será utilizado luego en el diseño y la implementación.
En el AOO los objetos encapsulan tanto atributos como procedimientos ( operaciones que se realizan sobre los objetos), e incorpora, además, conceptos como los polimorfismos o la herencia que facilitan la reutilización de código.
Podemos concluir entonces que el AOO puede facilitar mucho la creación de prototipos, y las técnicas de desarrollo evolutivo de software. Los objetos don inherentemente reutilizables, y se puede crear un catalogo de objetos que podemos usar en sucesivas aplicaciones. De esta forma, podemos obtener rápidamente un prototipo del sistema, que pueda ser evaluado por el cliente, a partir de los objetos analizados, diseñados e implementados en aplicaciones anteriores. Y lo que es más importante, dada la facilidad de reutilización de estos objetos, el prototipo puede ir evolucionando hacia convertirse en el sistema final, según vamos refinando los objetos de acuerdo a un proceso de especificación incremental.
VENTAJAS DEL AOO:
Dominio del problema
El paradigma OO es mas que una forma de programar. Es una forma de pensar acerca de un problema desde el punto de vista del mundo real en vez de desde el punto de vista del ordenador.
El AOO permite analizar mejor el dominio del problema, sin pensar en términos de implementar el sistema de un ordenador, permite, además, pasar directamente el dominio del problema al modelo del sistema.
Comunicación
El concepto OO es más simple y esta menos relacionado con la informática que el concepto de flujo de datos. Esto permite una mejor comunicación entre el analista y el experto en el dominio del problema.
Consistencia
Los objetos encapsulan tanto atributos como operaciones. Debido a esto, el AOO reduce la distancia entre el punto de vista de los datos y el punto de vista del proceso, dejando menos lugar a inconsistencias disparidades entre ambos modelos.
Expresión de características comunes
El paradigma lo utiliza la herencia para expresar explícitamente las características comunes de una serie de objetos estas característica comunes
quedan escondidas en otros enfoques y llevan a duplicar entidades en el análisis y código en los programas. Sin embargo, el paradigma OO pone especial énfasis en la reutilización y proporciona mecanismos efectivos que permiten reutilizar aquello que es común sin impedir por ello describir las diferencias.
Resistencia al cambio
Los cambios en los requisitos afectan notablemente a la funcionalidad de un sistema por lo que afectan mucho al software desarrollando con métodos estructurados. Sin embargo, los cambios afectan en mucha menos medida a los objetos que componen o maneja el sistema, que son mucho más estables. Las modificaciones necesarias para adaptar una aplicación basada en objetos a un cambio de requisitos suelen estar mucho más localizadas.
Reutilización
Aparte de la reutilización interna, basada en la expresión explícita de características comunes, el paradigma 00 desarrolla modelos mucho más próximos al mundo real, con lo que aumentan las posibilidades de reutilización. Es probable que en futuras aplicaciones nos encontremos con objetos iguales o similares a los de la actual.
ELEMENTOS FUNDAMENTALES DEL ANALISIS ORIENTADO A OBJETOS
EL MODELO DE OBJETOS
El modelo de objetos describe la estructura de los objetos de un sistema: su identidad, sus relaciones con otros objetos, sus atributos y sus operaciones. Los cambios y las transformaciones no tienen sentido a menos que haya algo que cambiar o transformar.
El modelo de objetos se representa gráficamente con diagramas de objetos y diagramas de instancias, que contienen clases de objetos e instancias respectivamente. Las clases se disponen en jerarquías que compartan una estructura de datos y un comportamiento común, y se relacionan con otras clases. Cada clase define los atributos que contiene cada uno de los objetos o instancias y las operaciones que realizan o sufren.
La tecnología orientada a objetos se apoya en sólidos fundamentos de la ingeniería, cuyos elementos reciben el nombre global de modelo de objetos. El modelo de objetos abarca principios fundamentales que los detallaremos mas adelante.
Quede claro que el diseño orientado a objetos es fundamentalmente diferente a los enfoques de diseño estructurado tradicionales; requiere un modo distinto de pensar acerca de la descomposición y produce arquitecturas software muy alejadas del dominio de la cultura del diseño estructurado.
Además, conviene mencionar que se observa que la mayoría de los programadores trabajan en un lenguaje y utilizan solo un estilo de programación. Programan bajo un paradigma apoyado por el lenguaje que usan. Frecuentemente, no se les han mostrado vías alternativas para pensar sobre un problema, y por lo tanto tiene dificultades para apreciar las ventajas de elegir un estilo, mas apropiado para el problema que tienen entre manos.
No hay un estilo de programación que sea el mejor para todo tipo de aplicaciones. Por ejemplo, la programación orientada a reglas seria la mejor para el diseño de una base de conocimiento, y la programación orientada a procedimientos seria la mas indicada parea el diseño de operaciones de calculo intensivo. Por experiencia de algunos estudiosos de la materia, el estilo orientado a objetos es él mas adecuado para él más amplio conjunto de aplicaciones; realmente, este paradigma de programación sirve con frecuencia como el marco de referencia arquitectónico en el que se emplean otros paradigmas.
Cada uno de estos estilos de programación se basa en su propio marco de referencia conceptual. Cada uno requiere una actitud mental diferente, una forma distinta de pensar en el problema. Para todas las cosas orientadas a objetos, el marco de referencia conceptual es el modelo de objetos.
FUNDAMENTOS DEL MODELO DE OBJETOS:
En realidad, el modelo de objetos ha recibido la influencia de una serie de factores, no solo de la programación orientada a objetos. El modelo de objetos a demostrado ser un concepto u unificador de en la informática. La razón de este gran atractivo es simplemente que una orientación a objetos ayuda a combatir la complejidad inherente a muchos tipos de sistemas diferentes.
El diseño orientado a objetos representa así un desarrollo evolutivo, no revolucionario; no rompe con los avances del pasado, sino que se basa en avances ya probados.
Los métodos de diseñó estructurado surgieron para guiar a los desarrolladores que intentaban construir sistemas complejos utilizando los algoritmos como bloques fundamentales para su construcción. Análogamente los métodos de diseño orientados a objetos han surgido para ayudar a los desarrolladores a explotar la potencia expresiva de los lenguajes de
programación basados en objetos y orientados a objetos, utilizando las clases como bloques básicos de construcción
Desgraciadamente, hoy en día la mayoría de los programadores han sido educados formal e informalmente solo en los principios del diseño estructurado.
En el modelo de objetos es necesario estudiar los principios fundamentales en los que se basa el análisis orientado a objetos, es decir;
· Abstracción
· Encapsulación
· Modularidad
· Jerarquía
· Concurrencia
Ninguno de estos principios es nuevo por sí mismo. Lo importante del modelo de objetos es el echo de conjugar todos estos elementos en forma sinérgica.
Al decir fundamentales, quiere decir que un modelo que carezca de cualquiera de estos elementos no estará orientado a objetos.
Otros elementos que podrían llamarse secundarios, que quiere decir, que cada uno de ellos es una parte útil del modelo de objetos, pero no esenciales son:
· Tipos
· Persistencia
A partir de los elementos antes mencionados, trataremos de mostrar, mediante una definición en primer lugar de cada uno de ellos, cual es la asociación con el sistema solar y el sistema celular, esto quiere decir que asociaremos estos elementos bases de la llamada teoría de los objetos con el macrocosmo y el microcosmo, dictando sus características fundamentales para el entendimiento claro de este. A la vez, también definiremos las desigualdades u oposiciones de estos elementos con los sistemas antes mencionados.
En otras palabras veremos como pasamos de un análisis estructurado a un análisis orientado a objetos, y viceversa. Macrocosmo v/s Microcosmo, esto incorporado al sistema de la teoría de los objetos.
1.3 Relaciones entre clases y objetos
Relaciones entre clases y objetos
Todo objeto es el ejemplo de una clase, y toda clase tiene 0 o más objetos. Mientras las clases son estáticas, con semántica, relaciones y existencia fijas previamente a la ejecución de un programa, los objetos se crean y destruyen rápidamente durante la actividad de una aplicación.
El diseño de clases y objetos es un proceso incremental e iterativo. Debe asegurar la optimización en los parámetros:
* Acoplamiento: Grado de acoplamiento entre módulos.
* Cohesión: Mide el grado de conectividad entre elementos de un módulo, y entre objetos de una clase.
* Suficiencia: Indica que las clases capturan suficientes características de la abstracción para conseguir un comportamiento e interacción eficiente y con sentido.
* Completitud: Indica que la interface de la clase captura todo el significado característico de una abstracción, escrito en el mínimo espacio.
* Primitividad: Las operaciones deben implementarse si dan acceso a una representación fundamental de la abstracción. Cuales son operaciones primitivas y cuales no (se pueden realizar a partir de otras) es un asunto subjetivo y afecto a la eficiencia en la implementación.
Todo objeto es el ejemplo de una clase, y toda clase tiene 0 o más objetos. Mientras las clases son estáticas, con semántica, relaciones y existencia fijas previamente a la ejecución de un programa, los objetos se crean y destruyen rápidamente durante la actividad de una aplicación.
El diseño de clases y objetos es un proceso incremental e iterativo. Debe asegurar la optimización en los parámetros:
* Acoplamiento: Grado de acoplamiento entre módulos.
* Cohesión: Mide el grado de conectividad entre elementos de un módulo, y entre objetos de una clase.
* Suficiencia: Indica que las clases capturan suficientes características de la abstracción para conseguir un comportamiento e interacción eficiente y con sentido.
* Completitud: Indica que la interface de la clase captura todo el significado característico de una abstracción, escrito en el mínimo espacio.
* Primitividad: Las operaciones deben implementarse si dan acceso a una representación fundamental de la abstracción. Cuales son operaciones primitivas y cuales no (se pueden realizar a partir de otras) es un asunto subjetivo y afecto a la eficiencia en la implementación.
1.2.1 Los lenguajes orientados a objetos
El desarrollo de software “OO” (Orientado a Objetos)se basa en el diseño y construcción de objetos que se componen a su vez de datos y operaciones que manipulan esos datos. Las ventajas de la programación orientada a objetos se derivan esencialmente de la estructura modular existente en la vida real y el modo de respuesta de estos módulos u objetos a mensajes o eventos que se producen a cualquier instante.
Los orígenes de la POO se remontan a los tipos abstractos de datos como parte constitutiva de una estructura de datos. C++, lenguaje orientado a objetos, por excelencia, es una extensión del lenguaje C y contiene las tres propiedades más importantes: encapsulamiento, herencia y polimorfismo. Smalltalk es otro lenguaje orientado a objetos muy potente y de gran impacto en el desarrollo de software orientado a objetos que se ha realizado en las últimas décadas.
Hoy día Java y C# son herederos directos de C++ y C y constituyen los lenguajes orientados a objetos más utilizados en la industria del software del siglo XXl. Visual Basic y VB.Net son otros lenguajes orientados a objetos, no tan potentes como los anteriores pero extremadamente sencillos y fáciles de aprender.
Los orígenes de la POO se remontan a los tipos abstractos de datos como parte constitutiva de una estructura de datos. C++, lenguaje orientado a objetos, por excelencia, es una extensión del lenguaje C y contiene las tres propiedades más importantes: encapsulamiento, herencia y polimorfismo. Smalltalk es otro lenguaje orientado a objetos muy potente y de gran impacto en el desarrollo de software orientado a objetos que se ha realizado en las últimas décadas.
Hoy día Java y C# son herederos directos de C++ y C y constituyen los lenguajes orientados a objetos más utilizados en la industria del software del siglo XXl. Visual Basic y VB.Net son otros lenguajes orientados a objetos, no tan potentes como los anteriores pero extremadamente sencillos y fáciles de aprender.
1.2 Conceptos fundamentales de la programación Orientada a Objetos
Abstracción:
Es el principio que permite (Al observar el objeto o concepto que se quiere representar) ignorar aquellos aspectos que no son relevantes, para de esta manera concentrarse en los que sí lo son. Se trata de abstraer los datos (llamados métodos) comunes a un conjunto de objetos y agruparlos bajo un mismo concepto llamado clase.
Encapsulamiento (Ocultamiento de información):
Se refiere a incluir dentro de la definición o de una clase todo lo que se necesita, de tal forma que ningún otro objeto requiera conocer su estructura interna para poder usarla. Es decir, se tomará cada clase y en consecuencia cada objeto como una unidad básica de la cual:
Ejemplo de abstracción:
Clase estudiante:
Atributos: Nombre: Edad: Sexo: Dirección: Teléfono: Boleta…
Métodos:
Actualiza_Nombre
Actualiza_Dirección
Calcula_Promedio
Determina_Beca
Herencia:
Clase Persona:
Atributos:
Nombre, dirección, teléfono, RFC…
Métodos:
Actualiza_Nombre ()
Actualiza_Dirección ()
Imprime_Datos ()
En este caso “heredamos” atributos para no volver a definirlos. (Y determinar cada atributo de las clases derivadas).
Polimorfismo:
En POO, se refiere a que un mismo método puede tener diferentes formas de acuerdo a la clase a la cual se aplique.
Constructor:
Es el método que nos sirve para inicializar los atributos de la clase, cuando se inicializa el objeto con el momento que se declara.
Características:
* Tiene el mismo nombre de la clase.
* El constructor no regresa ningún valor.
* Se ejecuta automáticamente en el momento de la declaración del objeto.
* Se puede sobrecargar (puede tener más de un constructor por clase).
* No se heredan.
* Se declaran en la sección pública de la clase.
Destructor:
Son un tipo especial de función miembro, están estrechamente relacionados con los constructores. Son funciones de tipo void, es decir, no hay retorno, ni aceptan parámetros.
Declaración:
Los destructores se distinguen porque llevan el mismo nombre que la clase al que pertenecen precedido de la tilde (~) para simbolizar su relación con el constructor que utiliza el mismo nombre.
Ejemplo:
class x {
public:
~x (); //destructor de la clase x
};
X: ~x (); {//Definición (off-line) del destructor.
}
Es el principio que permite (Al observar el objeto o concepto que se quiere representar) ignorar aquellos aspectos que no son relevantes, para de esta manera concentrarse en los que sí lo son. Se trata de abstraer los datos (llamados métodos) comunes a un conjunto de objetos y agruparlos bajo un mismo concepto llamado clase.
Encapsulamiento (Ocultamiento de información):
Se refiere a incluir dentro de la definición o de una clase todo lo que se necesita, de tal forma que ningún otro objeto requiera conocer su estructura interna para poder usarla. Es decir, se tomará cada clase y en consecuencia cada objeto como una unidad básica de la cual:
Ejemplo de abstracción:
Clase estudiante:
Atributos: Nombre: Edad: Sexo: Dirección: Teléfono: Boleta…
Métodos:
Actualiza_Nombre
Actualiza_Dirección
Calcula_Promedio
Determina_Beca
Herencia:
Clase Persona:
Atributos:
Nombre, dirección, teléfono, RFC…
Métodos:
Actualiza_Nombre ()
Actualiza_Dirección ()
Imprime_Datos ()
En este caso “heredamos” atributos para no volver a definirlos. (Y determinar cada atributo de las clases derivadas).
Polimorfismo:
En POO, se refiere a que un mismo método puede tener diferentes formas de acuerdo a la clase a la cual se aplique.
Constructor:
Es el método que nos sirve para inicializar los atributos de la clase, cuando se inicializa el objeto con el momento que se declara.
Características:
* Tiene el mismo nombre de la clase.
* El constructor no regresa ningún valor.
* Se ejecuta automáticamente en el momento de la declaración del objeto.
* Se puede sobrecargar (puede tener más de un constructor por clase).
* No se heredan.
* Se declaran en la sección pública de la clase.
Destructor:
Son un tipo especial de función miembro, están estrechamente relacionados con los constructores. Son funciones de tipo void, es decir, no hay retorno, ni aceptan parámetros.
Declaración:
Los destructores se distinguen porque llevan el mismo nombre que la clase al que pertenecen precedido de la tilde (~) para simbolizar su relación con el constructor que utiliza el mismo nombre.
Ejemplo:
class x {
public:
~x (); //destructor de la clase x
};
X: ~x (); {//Definición (off-line) del destructor.
}
1.1: Evolución de la programación
Una computadora es un dispositivo electrónico que procesa información de modo automático, las señales eléctricas se mueven entre los diferentes componentes de una computadora. Existen dos tipos de señales eléctricas: analógica y digital. Las señales analógicas se utilizan para representar cosas como un sonido; las cintas de audio, por ejemplo almacenan los datos en señales analógicas.
Las computadoras funcionan con señales digitales, las cuales representan la información como una secuencia de ceros y unos. Un cero representa una señal de bajo voltaje, y un 1, una señal de alto voltaje.
Las señales digitales se procesan en el interior de las computadoras, llamado lenguaje máquina, es una secuencia de dígitos 0 y 1. El dígito 0 y 1 se llama dígito binario o bit. Normalmente una secuencia de ceros y unos se conoce como código binario.
La mayoría de los lenguajes básicos de computadora, como el lenguaje máquina, proporcionan las instrucciones a la computadora en bits. Aunque la mayoría de las computadoras utilizan los mismos tipos de operaciones, los diseñadores de los diferentes procesadores (CPU) normalmente elijen conjuntos distintos de códigos binarios para realizar dichas operaciones. Por consiguiente el lenguaje máquina de una computadora no es necesariamente el mismo que el lenguaje máquina de otra computadora.
Las primeras computadoras eran programadas en lenguaje máquina (código binario), era un proceso tedioso y difícil de realizar, el programador tenía que recordar la posición de los datos en memoria, haciendo la programación propensa a errores.
Por esta razón comenzaron a crearse lenguajes ensambladores, para hacer la tarea del programador más fácil. Aunque es mucho más fácil escribir instrucciones en lenguaje ensamblador, una computadora no puede ejecutar instrucciones
directamente en este lenguaje, por consiguiente se diseñaron y construyeron lenguajes de alto nivel, que estaban más próximos a los lenguajes hablados como el español, francés e inglés.
Así aparecieron lenguajes como COBOL, Basic, FORTRAN, Pascal, C++. Java… etc., denominados lenguajes de alto nivel y cuyas instrucciones eran: print, read, open, write, for, while…
Al igual que sucede con los lenguajes ensambladores, las computadoras no pueden ejecutar directamente las instrucciones escritas en un lenguaje de alto nivel. Se necesita un programa traductor denominado compilador que traduzca las instrucciones en lenguaje de alto nivel a instrucciones en lenguaje máquina.
Las computadoras funcionan con señales digitales, las cuales representan la información como una secuencia de ceros y unos. Un cero representa una señal de bajo voltaje, y un 1, una señal de alto voltaje.
Las señales digitales se procesan en el interior de las computadoras, llamado lenguaje máquina, es una secuencia de dígitos 0 y 1. El dígito 0 y 1 se llama dígito binario o bit. Normalmente una secuencia de ceros y unos se conoce como código binario.
La mayoría de los lenguajes básicos de computadora, como el lenguaje máquina, proporcionan las instrucciones a la computadora en bits. Aunque la mayoría de las computadoras utilizan los mismos tipos de operaciones, los diseñadores de los diferentes procesadores (CPU) normalmente elijen conjuntos distintos de códigos binarios para realizar dichas operaciones. Por consiguiente el lenguaje máquina de una computadora no es necesariamente el mismo que el lenguaje máquina de otra computadora.
Las primeras computadoras eran programadas en lenguaje máquina (código binario), era un proceso tedioso y difícil de realizar, el programador tenía que recordar la posición de los datos en memoria, haciendo la programación propensa a errores.
Por esta razón comenzaron a crearse lenguajes ensambladores, para hacer la tarea del programador más fácil. Aunque es mucho más fácil escribir instrucciones en lenguaje ensamblador, una computadora no puede ejecutar instrucciones
directamente en este lenguaje, por consiguiente se diseñaron y construyeron lenguajes de alto nivel, que estaban más próximos a los lenguajes hablados como el español, francés e inglés.
Así aparecieron lenguajes como COBOL, Basic, FORTRAN, Pascal, C++. Java… etc., denominados lenguajes de alto nivel y cuyas instrucciones eran: print, read, open, write, for, while…
Al igual que sucede con los lenguajes ensambladores, las computadoras no pueden ejecutar directamente las instrucciones escritas en un lenguaje de alto nivel. Se necesita un programa traductor denominado compilador que traduzca las instrucciones en lenguaje de alto nivel a instrucciones en lenguaje máquina.
Suscribirse a:
Entradas (Atom)