Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Universidad de Carabobo
Facultad Experimental de Ciencias y Tecnología
Algoritmos y Programación II
Enero de 2005
1. Definición de Clases
• datos (datos miembro o campos), los cuales especifican las propiedades de los
objetos.
• funciones (funciones miembro o métodos), mediante los cuales se modela su
comportamiento y las acciones que puede realizar.
1 class Triangulo
2 {
3 private:
4 float cat_opuesto;
5 float cat_adyacente;
6 float hipotenusa;
7
8 // Declaración de métodos
9 };
2. Constructores y Destructores
1 class MiClase
2 {
3 public:
4 int *arreglo;
5
6 // Constructor
7
8 MiClase ()
9 {
10 arreglo = new int[10];
11 }
12
13 // Destructor
14
15 ~MiClase ()
16 {
17 delete [] arreglo;
18 }
19 };
3. Métodos
1 #ifndef triangulo_h
2 #define triangulo_h
3
4 class Triangulo
5 {
6 private:
7 float cat_opuesto;
8 float cat_adyacente;
9 float hipotenusa;
10
11 public:
12 // Constructor de la clase
13 Triangulo();
14
15 // Métodos de inspección
16 float VerOpu();
17 float VerAdy();
18 float VerHip();
19 void MostrarTriangulo();
20
21 // Métodos de modificación
22 void ModOpu(float valor);
23 void ModAdy(float valor);
24 void ModHip(float valor);
25 void ModificarTriangulo(float ady, float op,
26 float hip);
27 };
28
29 #endif
1 #include <iostream>
2 #include “triangulo.h”
3
4 using namespace std;
5
6 // Constructor de la clase
7 Triangulo::Triangulo()
8 {
9 this->cat_opuesto = 0;
10 cat_adyacente = 0;
11 hipotenusa = 0;
12 }
13
14 // Métodos de inspección
15 float Triangulo::VerOpu()
16 {
17 return cat_opuesto;
18 }
19
20 float Triangulo::VerAdy()
21 {
22 return cat_adyacente;
23 }
24
25 float Triangulo::VerHip()
26 {
27 return hipotenusa;
28 }
29
30 void Triangulo::MostrarTriangulo()
31 {
32 cout << "Cateto Opuesto: " << VerOpu() << endl;
33 cout << "Cateto Adyacente: " << VerAdy() << endl;
34 cout << "Hipotenusa: " << VerHip() << endl;
35 }
36
37 // Métodos de modificación
38 void Triangulo::ModOpu(float valor)
39 {
40 cat_opuesto = valor;
41 }
42
43 void Triangulo::ModAdy(float valor)
44 {
45 cat_adyacente = valor;
46 }
47
48 void Triangulo::ModHip(float valor)
49 {
50 hipotenusa = valor;
51 }
52
53 void Triangulo::ModificarTriangulo(float ady,
54 float op, float hip)
55 {
56 ModOpu(op);
57 ModAdy(ady);
58 ModHip(hip);
59 }
4. Instanciación
1 void main ()
2 {
3 // Instanciación estática
4 Triangulo a;
5
6 // Instanciación dinámica
7 Triangulo *b;
8 b = new Triangulo;
9
10 ...
11
12 delete b;
13 }
5. Paso de Mensajes
1 #include <iostream>
2
3 class A
4 {
5 private:
6 ...
7
8 public:
9 int Op1() { ... }
10 };
11
12 class B
13 {
14 public:
15 int x;
16
17 int Op2(A obj) { return (x + obj.Op1()); }
18 };
19
20 void main ()
21 {
22 A obj1;
23 B obj2;
24
25 ...
26
27 obj2.x = 100;
28
29 // Paso de mensaje
30 cout << obj2.Op2(obj1);
31 }
1 #include <iostream>
2 #include “triangulo.h”
3
4 Triangulo::Copiar(Triangulo t)
5 {
6 cat_opuesto = t.VerOpu();
7 cat_adyacente = t.VerAdy();
8 hipotenusa = t.VerHip();
9 }
10
11 void main ()
12 {
13 Triangulo t1, t2;
14
15 cout << “Triangulo t1” << endl;
16 t1.MostrarTriangulo();
17 t1.ModOpu(3.3);
18 t1.ModAdy(5.0);
19 t1.ModHip(7.0);
20 cout << “Triangulo t1 modificado” << endl;
21 t1.MostrarTriangulo();
22 t2.ModificarTriangulo(1.0, 1.0, 1.0);
23
24 // Paso de mensaje
25 t1.Copiar(t2);
26
27 cout << “Triangulo t1 copiado de t2” << endl;
28 t1.MostrarTriangulo();
29 }
6. Herencia
Sintaxis
NOTA: Si la clase base posee un único constructor que recibe unos parámetros,
entonces el encabezado del constructor de la clase derivada debe invocar al constructor de
la clase base con los parámetros requeridos. Un ejemplo de esto se puede apreciar en el
siguiente fragmento de código:
1 class A
2 {
3 private:
4 ...
5
6 public:
7 A(int x, int y) { ... }
8 ...
9 };
10
11 class B : public A
12 {
13 private:
14 int z;
15
16 public:
17 B(int x, int y, int z) : A(x,y)
18 {
19 this->z = z;
20 }
21 ...
22 };