UNIDAD 1: CONCEPTOS BÁSICOS
TAREA 1: TRES CONCEPTOS DE PROGRAMACIÓN ORIENTADA A OBJETOS
1.- La Programación Orientada a Objetos (POO u OOP) es un paradigma de programación que define los programas en términos de “clases de objetos”, objetos que son entidades que combinan estado (propiedades o datos), comportamiento (procedimientos o métodos) e identidad (propiedad del objeto que lo diferencia del resto). La programación orientada a objetos expresa un programa como un conjunto de estos objetos, que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y módulos más fáciles de escribir, mantener y reutilizar.
2.- La orientación a objetos es un paradigma de programación que facilita la creación de software de calidad por sus factores que potencian el mantenimiento, la extensión y la reutilización del software generado bajo este paradigma.
La programación orientada a objetos trata de amoldarse al modo de pensar del hombre y no al de la máquina. Esto es posible gracias a la forma racional con la que se manejan las abstracciones que representan las entidades del dominio del problema, y a propiedades como la jerarquía o el encapsulamiento.
El elemento básico de este paradigma no es la función (elemento básico de la programación estructurada), sino un ente denominado objeto. Un objeto es la representación de un concepto para un programa, y contiene toda la información necesaria para abstraer dicho concepto: los datos que describen su estado y las operaciones que pueden modificar dicho estado, y determinan las capacidades del objeto.
3.- Programación Orientada a Objetos (POO): Metodo de Implementacion en el que los programas se organizan como colecciones cooperativas de objetos, cada uno de los cuales representa una instancia de alguna clase, y cuyas clases son miembros de una jerarquia de clases unidas mediante relaciones de herencia. En tales programas las clases suelen verse estaticas, mientras que los objetos suelen tener una naturaleza mucho mas dinamica, promovida por la evidencia de la ligadura dinamica y el polimorfismo.
Mi propia definición:
Creo que Programación Orientada a Objetos es como una técnica que sirve para desarrollar soluciones computacionales utilizando los componentes de lenguajes de programación. Con la POO tenemos que aprender a pensar las cosas de una manera muy distinta, para escribir nuestros programas en términos de objetos, propiedades, métodos, etc.
TAREA 2: MAPA MENTAL
TAREA 3: PRESENTACION PREZI
UNIDAD II: EL PARADIGMA DE ORIENTACIÓN A OBJETOS
TAREA 1: EXPOSICIÓN EN EQUIPO
TAREA 2: CUESTIONARIO
1.- ¿Qué es un componente?
Es una clase de uso específico, lista para usar, que puede ser configurada o utilizada de forma visual, desde el entorno de desarrollo. El componente es el principal responsable de dibujar en la pantalla lo que sea oportuno, dependiendo de su estado, del valor de sus atributos, etc.
2.- ¿Cuántos tipos de componentes hay y cuáles son?
Hay 2 tipos y son: “Visuales” y “No visuales” .
3.- ¿Qué son los componentes visuales?
Los componentes visuales son aquellos que, al utilizarlos, muestran algún elemento (o dibujo) en la pantalla y es el usuario de nuestros programas el que interactúa con él.
4.- ¿Qué son los componentes no visuales?
Los componentes no visuales son aquellos que no aparecen en la ventana, y se insertan en un formulario para que el programador los utilice. Son más fáciles de programar que los componentes visuales, ya que no tienen ningún tipo de interfaz gráfico.
5.- ¿Cómo esta compuesto un componente?
Todo componente esta compuesto por propiedades, eventos, métodos y atributos.
6.- ¿Qué son las propiedades?
Las propiedades son datos públicos del componente, muy parecidas a los atributos de una clase, aunque se accede a ellas a través de dos métodos: un método para leer su valor, y otro para modificarlo.
7.- ¿Qué son los eventos?
Los eventos son funciones del componente, que se ejecutarán automáticamente cuando ocurra “algo importante”.
8.- ¿Qué son los métodos?
Los métodos son funciones, que permiten realizar acciones. Normalmente, se utilizan métodos para dos tareas distintas: realizar algo importante (como repintar en pantalla, cambiar el foco o algo así), o para establecer el valor de los atributos internos, haciendo algún tipo de comprobación previa.
Son aquellos en los que se puede almacenar datos internos al objeto (o clase).
10.- ¿Qué es la programación orientada a objetos?
Es un paradigma de programación que usa los objetos en sus interacciones, para diseñar aplicaciones y programas informáticos.
11.- ¿Cuáles son las características de la POO?
Existe un acuerdo acerca de qué características contempla la "orientación a objetos", las características siguientes son las más importantes:
- Abstracción
- Encapsulamiento
- Modularidad
- Principio de ocultación
- Polimorfismo
- Herencia
- Recolección de basura
12.- ¿Qué es la abstracción?
Es aquella que denota las características esenciales de un objeto, donde se capturan sus comportamientos. Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar cómo se implementan estas características.
13.- ¿Qué es el encapsulamiento?
Es aquello que puede reunir a todos los elementos que pueden considerarse pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite aumentar la cohesión de los componentes del sistema.
14.- ¿A que se le denomina modularidad?
Se denomina modularidad a la propiedad que permite subdividir una aplicación en partes más pequeñas (llamadas módulos), cada una de las cuales debe ser tan independiente como sea posible de la aplicación en sí y de las restantes partes.
15.- ¿Qué es el principio de ocultación?
15.- ¿Qué es el principio de ocultación?
Es un módulo natural, y cada tipo de objeto expone una interfaz a otros objetos que específica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas, solamente los propios métodos internos del objeto pueden acceder a su estado.
16.- ¿Qué es el polimorfismo?
Son los comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando. O dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del objeto referenciado.
17.- ¿Qué es la herencia?
Son aquellas clases que no están aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento permitiendo a los objetos ser definidos y creados como tipos especializados de objetos prexistentes.
18.- ¿Qué es la recolección de basura?
Es la técnica por la cual el entorno de objetos se encarga de destruir automáticamente, y por tanto desvincular la memoria asociada, los objetos que hayan quedado sin ninguna referencia a ellos. Esto significa que el programador no debe preocuparse por la asignación o liberación de memoria, ya que el entorno la asignará al crear un nuevo objeto y la liberará cuando nadie lo esté usando.
19.- ¿Qué es un paradigma?
Es la forma de entender y representar la realidad. Es un conjunto de teorías, estándares y métodos que, juntos, representan un modo de organizar el pensamiento, es decir, el modo de ‘ver’ el mundo.
20.- ¿Por qué la POO es tan popular?
· POO se ha convertido durante las pasadas dos décadas en el paradigma de programación dominante, y en una herramienta para resolver la llamada crisis del software.
· POO se escala muy bien, desde el problema más trivial hasta la tarea más compleja.
· POO proporciona un modelo de abstracción que razona con técnicas que la gente usa para resolver problemas en sus vidas (metáforas).
21.- ¿Cuáles son los elementos básicos de la POO?
- Los bloques
- Los métodos
- Los mensajes y
- Las clases.
22.- ¿Qué son los bloques?
Son un conjunto complejo de datos (atributos) y funciones (métodos) que poseen una determinada estructura y forman parte de una organización.
23.- ¿Qué es un método?
23.- ¿Qué es un método?
Es un programa procedimental que esta asociado a un objeto determinado y cuya ejecución solo puede desencadenarse a través del mensaje correspondiente.
24.- Dentro de los métodos ¿qué puede incluirse?
· Declaraciones de variables locales.
· Asignaciones a variables.
· Operaciones matemáticas.
· Llamados a otros métodos.
· Estructuras de control.
· Excepciones.
25.- ¿Qué son los mensajes?
Es simplemente una petición de un objeto a otro para que este se comporte de una manera
determinada, ejecutando uno de sus métodos. Los mensajes comunican a los objetos con otros y con el mundo exterior.
determinada, ejecutando uno de sus métodos. Los mensajes comunican a los objetos con otros y con el mundo exterior.
26.- ¿Qué es una clase?
Es un tipo definido por el usuario que determina la estructura de datos y las operaciones
asociadas con ese tipo.
asociadas con ese tipo.
27.- ¿Cómo se dividen los lenguajes de la POO y cuáles son?
En 2: Puros e Híbridos.
28.- ¿Qué son los lenguajes puros?
Son los que solo permiten realizar programación orientada a objetos. Ejemplo: smalltalk, java.
29.- ¿Qué son los lenguajes híbridos?
Son los que permiten la POO con la programación estructurada. Ejemplo: c++, pascal.
30.- ¿Qué es un objeto?
Es una instancia de una clase. Por lo tanto, los objetos hacen uso de los atributos (variables) y métodos (Funciones y Procedimientos) de su correspondiente clase.
http://www.wikilearning.com/curso_gratis/creacion_de_componentes_vcl_i-pero_que_es_un_componente/3844-2
http://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos
http://es.wikipedia.org/wiki/Paradigma_de_programaci%C3%B3n
http://rua.ua.es/dspace/bitstream/10045/4011/1/1-IntroPOO-v0.5.pdf
http://www.monografias.com/trabajos14/paradigma/paradigma.shtml
UNIDAD III: CLASES Y OBJETOS
TAREA 1: CUESTIONARIO DEL ARCHIVO HORA 3
1.-¿Cómo se representa una clase en el UML?
En UML un rectángulo es el símbolo que representa una clase.
2.-¿Qué información puede mostrar en un símbolo de clase?
El nombre de la clase es, por convención, una palabra con la primera letra en mayúscula y normalmente se coloca en la parte superior del rectángulo.
3.-¿Qué es una restricción?
Es un texto libre bordeado por llaves; este texto especifica una o varias reglas que sigue la clase.
4.-¿Para qué adjuntaria una nota a un símbolo de clase?
Para que una nota proporcione mayor informacion respecto a la clase.
UNIDAD IV: FUNCIONES EN C++
PROGRAMA 4.1: FUNCIONES INLINE
#include<conio.h>
#include<stdio.h>
#include <iostream>
using namespace std;
inline float mul (float x, float y)
{
return (x*y);
}
inline double div(double p, double q)
{
return (p/q);
}
int main ()
{
float a=12.345;
float b=9.82;
cout << mul(a,b)<< "\n";
cout << div(a,b)<< "\n";
return (0);
getch();
}
PROGRAMA 4.2: ARGUMENTOS PREDETERMINADOS
#include <iostream>
#include<conio.h>
using namespace std;
int main()
{
float cantidad;
float valor(float p, int n, float r = 0.15); //prototipo
float imprimeLinea(char ch='*', int len = 40); //prototipo
imprimeLinea(); //utiliza los valores predeterminados
cantidad = valor(5750.00, 4); //utiliza el valor
//predeterminado para el tercer argumento
cout << "\n Valor Final = " << cantidad << "\n\n";
imprimeLinea(); // utiliza el valor predeterminado
// para el 2° argumento
getch ();
return 0;
}
/***********************************************************************/
float valor(float p, int n, float r)
{
int annio = 1;
float suma = p;
while (annio <= n)
{
suma = suma * (1 + r);
annio = annio + 1;
}
return suma;
}
void imprimeLinea(char ch, int len)
{
for (int i=1; i<=len; i++) printf("%c", ch);
printf("\n");
}
PROGRAMA 4.3: SOBRECARGA DE FUNCIONES
// La funcion volumen() se sobrecarga tres veces
#include <iostream>
#include<conio.h>
using namespace std;
// Declaraciones (prototipos)
int volumen(int);
double volumen(double, int);
long volumen(long, int, int);
int main()
{
cout << volumen(10) << "\n";
cout << volumen(2.5, 8) << "\n";
cout << volumen(100L, 75, 15) <<"\n";
getch ();
return 0;
}
//Definicion de las funciones
int volumen(int s) //cubo
{
return (s*s*s);
}
double volumen(double r, int h) // cilindro
{
return (3.14519*r*r*h);
}
long volumen(long l, int b, int h) // caja rectangular
{
return (l*b*h);
}
UNIDAD V: CLASES Y OBJETOS
PROGRAMA 5.1: IMPLEMENTACIÓN DE UNA CLASE
#include
<iostream>
#include
<conio.h>
using namespace
std;
class
articulo{
int numero; //privado por defecto
float coste; //privado por defecto
public:
void putdata(int a, float b); //declaración de prototipo,
// a defenir posteriormente
//función definida dentro de la clase
void getdata(void);
{
cout << "numero :" << numero << "\n";
cout << "coste :" << coste << "\n";
}
};
//.......................Definición de función miembro...................
void articulo :: putdata (int a, float b)
//usa etiqueta de pertenencia
{numero = a; //variables privadas
coste = b; //usadas directamente
}
//..............Programa principal.................................
int main ()
{
articulo x; //crea objeto x
cout << "\nobjeto x " << "\n";
x.putdata(100,299.95); //llama a función miembro
x.getdata(); //llama a función miembro
articulo y; // crea otro objeto
cout << "\nobjeto y" << "\n";
y.putdata(200, 175.50);
y.getdata();
getch ();
return 0;
}
#include
<iostream>
#include
<conio.h>
using
namespace std;
class set
{
int m, n;
public:void leer(void);
void mostrar(void);
int mayor(void);
};
int set :: mayor(void)
{
if(m >= n)
return (m);
else
return (n);
}
void set :: leer(void)
{
cout << "introduzca valores de m y n" << "\n";
cin >> m >> n;
}
void set :: mostrar (void)
{
cout <<
"mayor valor = "
<< mayor ()
<< "\n"; // llamada a función miembro}
int main ()
{set A;
A.leer();
A.mostrar();
getch ();
return 0;
}
PROGRAMA 5.3: PROCESAR LISTA DE LA COMPRA
#include <iostream>
#include <conio.h>
#include <match.h>
using
namespace std;
const m=50;
class
ARTICULOS
{int codigoArticulo[m];
float precioArticulo[m];
int cuenta;
public:
void CNT(void)(cuenta = 0;) //función inicializada a 0
void obtenerArticulo(void);
void mostrarSuma(void);
void eliminar (void);
void mostrarArticulos(void);
};
//===================================================================================
void ARTICULOS :: obtenerArticulo(void) //asigna valores a
//miembros de datos de articulo
{
cout << " Introduzca codigo de articulo :";
cin >> codigoArticulo[cuenta];
cout << " Introduzca precio de articulo :";
cin >> precioArticulo[cuenta];
count++;
}
void ARTICULOS :: mostrarSuma(void) //muestra el valor total
// de todos los articulos
{
float sum = 0;
for (int i=0; i<cuenta; i++)sum = sum + precioArticulo[i];
cout << "\nValor total :" << sum << "\n";
}
void ARTICULOS :: eliminar(void) //elimina un articulo
{
int a;
cout << " Introduzca codigo de articulo :";
cin >> a;
for (int i=0; i<cuenta; i++)
if (codigoArticulo[i]== a)
precioArticulo[i]=0;
}
void ARTICULOS :: mostrarArticulos(void) //muestra articulos
{
cout << "\nCodigo Precio\n";
for (int i=0; i<count; i++)
{
cout <<"\n" << codigoArticulo[i];
cout <<" " << precioArticulo[i];
}
cout << "\n";
}
//============================================================================
int main()
{
ARTICULOS pedido;
pedido.CNT();
int x;
do //bucle do.........while
{
cout << "\n Puede hacer lo siguiente;"
<< "Introduzca el número adecuado \n";
cout << "\n1 : Añadir un articulo";
cout << "\n2 : Mostrar el valor total";
cout << "\n3 : Eliminar un articulo";
cout << "\n4 : Mostrar todos los articulos";
cout << "\n5 : Salir";
cout << "\n\n : ¿Cual es su opción?";
cin < x;
switch (x)
{
case 1 : pedido.obtenerArticulo(); break;
case 2 : pedido.mostrarSuma(); break;
case 3 : pedido.eliminar(); break;
case 4 : pedido.mostrarArticulos(); break;
case 5 : break;
default : cout << " Opcion incorrecta\n";
}
} while (x != 5); //fin de bucle do......while
getch ();
return 0;
}
PROGRAMA 5.4: MIEMBRO DE CLASE ESTÁTICO
#include
<iostream>
#include
<conio.h>
using
namespace std;
class
articulo
{
static int cuenta;
int numero;
public:
void introducirdatos(int a)
{
número = a;
cuenta++;
}
void vercuenta(void)
{
cout <<
"cuenta: ";
cout << cuenta
<< "\n";
}
};
int articulo :: cuenta;
int main ()
{
articulo a, b,
c; //cuenta esta inicializado a cero
a.vercuenta(); // mostrar cuenta
b.vercuenta();
c.vercuenta();
a.introducirdatos(100); //introduce datos en a
b.introducirdatos(200); //introduce datos en b
c.introducirdatos(300); //introduce
datos en c
cout <<
"despues de cargar los datos " << "\n";
a.vercuenta(); //mostrar cuenta
b.vercuenta();
c.vercuenta();
getch ();
return 0;
}
PROGRAMA 5.5: FUNCIÓN MIEMBRO ESTÁTICA
#include
<iostream>
#include<conio.h>
using
namespace std;
class prueba
{
int codigo;
static int cuenta; // variable mienbro estatica
public:
void asignarcodigo(void)
{
codigo=++cuenta;
}
void mostrarcodigo(void)
{
cout <<"
número de objeto: "
<<codigo<<
"\n";
}
static void
mostrarcuenta(void)//función mienbro estatica
{
cout <<
"cuenta: " << cuenta<< "\n";
}
};
int prueba ::
cuenta;
int main()
{
prueba t1, t2;
t1.asignarcodigo();
t2.asignarcodigo();
prueba :: mostrarcuenta(); // acceso a la
funcioó
prueba t3;
t3.asignarcodigo();
prueba ::
mostrarcuenta();
t1.mostrarcodigo();
t2.mostrarcodigo();
t3.mostrarcodigo();
getch ();
return 0;
}
PROGRAMA 5.6: ARRAYS DE OBJETOS
#include <iostream>
#include
<conio.h>
using
namespace std;
class empleado
{
char nombre[30]; // cadena miembro de la clase
float edad;
public:
void putdata(void);
void getdata(void);
};
void empleado :: putdata(void)
{
cout << "introduzca el nombre: ";
cin >> nombre;
cout << "introduzca la edad: ";
cin >> edad;
}
void empleado :: getdata(void)
}
cout << "Nombre: " << nombre << "\n";
cout << "Edad: " << edad << "\n";
}
const int tamanyo=3;
int main()
{
empleado directivo[tamanyo];
for(int i=0; i<tamanyo; i++)
{
cout << "\nDetalles del directivo" << i+1 << "\n";
directivo[i].putdata();
}
cout << "\n";
for(int i=0; i<tamanyo; i++)
{
cout << "\ndirectivo" << i+1 << "\n";
directivo[i].getdata();
}
getch ();
return 0;
}
PROGRAMA 5.7: OBJETOS COMO ARGUMENTOS
#include
<iostream>
#include
<conio.h>
using namespace std;
class hora
{
int horas;
int minutos;
public:
void introducirhora(int h, int m)
{horas = h; minutos = m; }
void verhora(void)
{
cout << horas <<
" horas y ";
cout << minutos
<< "minutos " << "\n";
}
void suma(hora, hora); //declaracion con objetos
//como argumentos
};
void hora :: suma(hora t1, hora t2) //t1, t2 son objetos
{
minutos = t1.minutos + t2.minutos;
horas = minutos/60;
minutos= minutos%60;
horas = horas + t1.horas + t2.horas;
}
int main()
{
hora T1, T2, T3;
T1.introducirhora(2,45);
//introducir T1
T2.introducirhora(3,30); //introducir T2
T3.suma(T1,T2);
// T3=T1+T2
cout << " T1= ";
T1.verhora(); //mostrar T1
cout << " T2= ";
T2.verhora(); //mostrar T2
cout << " T3= ";
T3.verhora(); //mostrar T3
getch ();
return 0;
}
#include
<conio.h>
using
namespace std;
class ABC;
// declaracion adelantada
//-----------------------------------------------------------//
class XYZ
{
int x;
public:
void setvalue(int i) {x = i;}
friend void max(XYZ, ABC);
};
//----------------------------------------------------------//
class ABC
{
int a;
public:
void setvalue(int i) {a = i;}
friend void max(XYZ, ABC);
};
//---------------------------------------------------------//
void max(XYZ m, ABC n) //definicion de amiga
{
if(m.x >= n.a)
cout << m.x;
else
cout << n.a;
};
//-------------------------------------------------//
int main()
{
ABC abc;
abc.setvalue(10);
XYZ xyz;
xyz.setvalue(20);
max(xyz, abc);
getch ();
return 0;
}
class XYZ
{
int x;
public:
void setvalue(int i) {x = i;}
friend void max(XYZ, ABC);
};
//----------------------------------------------------------//
class ABC
{
int a;
public:
void setvalue(int i) {a = i;}
friend void max(XYZ, ABC);
};
//---------------------------------------------------------//
void max(XYZ m, ABC n) //definicion de amiga
{
if(m.x >= n.a)
cout << m.x;
else
cout << n.a;
};
//-------------------------------------------------//
int main()
{
ABC abc;
abc.setvalue(10);
XYZ xyz;
xyz.setvalue(20);
max(xyz, abc);
getch ();
return 0;
}
#include
<conio.h>
using namespace std;
class clase_2
using namespace std;
class clase_2
class
clase_1
{
int valor1;
int valor1;
public:
void indata(int a) {valor1 = a;}
void display(void) {cout << valor1 << "\n";}
friend void exchange(clase_1 &, clase_2 &);
}
class clase_2
{
int valor2;
public:
void indata(int a) {valor2 = a;}
void display(void) {cout << valor2 << "\n";}
friend void exchange(clase_1 &, clase_2 &);
}
void exchange(clase_1 & x, clase_2 & y)
{
int temp = x.valor1;
x.valor1 = y.valor2;
y.valor2 = temp
}
int main()
{
clase_1 C1;
clase_2 C2;
C1.indata(100);
C2indata(200);
void indata(int a) {valor1 = a;}
void display(void) {cout << valor1 << "\n";}
friend void exchange(clase_1 &, clase_2 &);
}
class clase_2
{
int valor2;
public:
void indata(int a) {valor2 = a;}
void display(void) {cout << valor2 << "\n";}
friend void exchange(clase_1 &, clase_2 &);
}
void exchange(clase_1 & x, clase_2 & y)
{
int temp = x.valor1;
x.valor1 = y.valor2;
y.valor2 = temp
}
int main()
{
clase_1 C1;
clase_2 C2;
C1.indata(100);
C2indata(200);
cout
<< "Valores antes de intercambiar" << "\n";
C1.display();
C2.display();
exchange(C1, C2); // intercambio de valores
cout << "Valores despues del intercambio " << "\n";
C1.display();
C2.display();
getch ();
return 0;
}
C1.display();
C2.display();
exchange(C1, C2); // intercambio de valores
cout << "Valores despues del intercambio " << "\n";
C1.display();
C2.display();
getch ();
return 0;
}
#include
<iostream>
#include
<conio.h>
using
namespace std;
class
complejo //forma x + iy
{float x; //parte real
float y; //parte imaginaria
public:
void input(float real, float imag)
{x = real; y = imag;}
friend complejo sum(complejo, complejo);
void show(complejo);
};
complejo sum(complejo c1,
complejo c2)
{complejo c3; // crea el objeto c3
c3.x = c1.x + c2.x;
c3.y = c1.y + c2.y;
return(c3); //devuelve el objeto c3
}
void complejo :: show(complejo c)
}
cout << c.x << " + j" << c.y << "\n";
}
int main()
{
complejo A, B, C;
A.input(3.1, 5.65);
B.input(2.75, 1.2);
C =
sum(A,B); //C = A + B
cout << "A = "; A.show(A);
cout << "B = "; B.show(B);
cout << "C = "; C.show(C);
getch ();
return 0;
}
PROGRAMA 5.12: OPERADORES DE DESREFERENCIACIÓN
#include <iostream>
#include <conio.h>
{
int x;
int y;
public:
void set_xy(int a, int b)
{
x = a;
y = b;
}
friend int sum(M m);
};
int sum(M m)
{
int M ::* px = &M :: x;
int M ::* py = &M :: y;
M *pm = &m;
int S = m.*px + pm->*py;
return S;
}
int main()
{
M n;
void (M :: *pf)(int,int) = &M :: set_xy;
(n.*pf)(10,20);
cout << "SUMA = " << sum(n) << "\n";
cout << "SUMA = " << sum(n) << "\n";
getch ();
return 0;
}
#include <iostream>
#include <conio.h>
using
namespace std;
class M{
int x;
int y;
public:
void set_xy(int a, int b)
{
x = a;
y = b;
}
friend int sum(M m);
};
int sum(M m)
{
int M ::* px = &M :: x;
int M ::* py = &M :: y;
M *pm = &m;
int S = m.*px + pm->*py;
return S;
}
int main()
{
M n;
void (M :: *pf)(int,int) = &M :: set_xy;
(n.*pf)(10,20);
cout << "SUMA = " << sum(n) << "\n";
M *op = &n;
(op->*pf)(30,40);cout << "SUMA = " << sum(n) << "\n";
getch ();
return 0;
}
UNIDAD VI: CONSTRUCTORES Y DESTRUCTORES
TAREA 1: EXPOSICIÓN EN EQUIPO:
UNIDAD VIII: HERENCIA: EXTENSIÓN DE CLASES
No hay comentarios:
Publicar un comentario