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;
}
Suscribirse a:
Entradas (Atom)