Introducing
Your new presentation assistant.
Refine, enhance, and tailor your content, source relevant images, and edit visuals quicker than ever before.
Trending searches
#include <iostream>
#include <conio.h>
using namespace std;
class estudiante
{
protected:
int roll_number;
public:
void get_number(int a)
{
roll_number = a;
}
void put_number(void)
{
cout << "Num Lista: " << roll_number << "\n";
}
};
class test : public estudiante
{
protected:
float part1, part2;
public:
void get_marks(float x, float y)
{
part1 = x; part2 = y;
}
void put_marks(void)
{
cout << "Puntuaciones Obtenidas: " << "\n"
<< "Parte1 = " << part1 << "\n"
<< "Parte2 = " << part2 << "\n";
}
};
class deportes
{
protected:
float score;
public:
void get_score(float s)
{
score = s;
}
void put_score(void)
{
cout << "Peso deportes: " << score << "\n";
}
};
class resultado : public test, public deportes
{
float total;
public:
void display(void);
};
void resultado :: display(void)
{
total = part1 + part2 + score;
put_number();
put_marks();
put_score();
cout << "Puntuacion total: " << total << "\n";
}
int main()
{
resultado estudiante_1;
estudiante_1.get_number(1234);
estudiante_1.get_marks(27.5, 33.0);
estudiante_1.get_score(6.0);
estudiante_1.display();
getch();
return 0;
}
EJEMPLO:
class ABC: private XYZ // derivacion privada
{
miembros de ABC
}:
class ABC: public XYZ // derivacion publica
{
miembros de ABC
}:
class ABC: XYZ // derivacion privada por defecto
{
miembro de ABC
}:
Una clase derivada puede ser definida especificando su relacion con la clase base a demas de sus propios detalles. el formato general de definicion de una clase derivada es:
class nombre-clase-derivada : modo-visibilidad nombre-clase-base
{
.......//
.......// mienbros de clase derivada
......//
}:
LAS CLASES BASE VIRTUALES SE GENERAN IMPLICANDO LOS 3 TIPOS DE HERENCIA;
ES DECIR MULTINIVEL, MULTIPLE Y JERARQUICA
//HERENCIA SIMPLE PRIVADA
#include <iostream>
#include <conio.h>
using namespace std;
class B
{
int a; // privado no heredable
public:
int b; // publico preparado para herencia
void get_ab();
int get_a(void);
void show_a(void);
};
class D : private B // derivacioj privada
{
int c;
public:
void mul(void);
void display (void);
};
//--------------------------------------
void B :: get_ab(void)
{
cout << "introduzca los valores de a y b:";
cin >> a >> b;
}
int B :: get_a()
{
return a;
}
void B :: show_a()
{
cout <<"a = " << a << "\n";
}
void D :: mul()
{
get_ab();
c = b * get_a(); // 'a' no puede usarse directamente
}
void D :: display()
{
show_a(); // muestra el valor 'a'
cout << "b = " << b << "\n"
<< "c = " << c << "\n\n";
}
//----------------------------------------
int main()
{
D d;
// d.get_ab(); NO FUNCIONARA
d.mul();
// d.show_a(); NO FUNCIONARA
d.display();
//d.b = 20; NO FUNCIONARA; ahora b es privada
d.mul();
d.display();
getch ();
return 0;
}
LAS PALABRAS RESERVADAS VIRTUAL Y PUBLIC
PUEDEN USARSE EN CUALQUIER ORDEN.
//HERENCIA SIMPLE
#include <iostream>
#include <conio.h>
using namespace std;
class B
{
int a; // privado; no heredable
public:
int b; // publico; preparado para herencia
void get_ab();
int get_a(void);
void show_a(void);
};
class D : public B // derivacion publica
{
int c;
public:
void mul(void);
void display(void);
};
//--------------------------------------------
void B :: get_ab(void)
{
a = 5; b = 10;
}
int B:: get_a()
{
return a;
}
void B :: show_a()
{
cout << "a = " << a << "\n";
}
void D :: mul()
{
c = b * get_a();
}
void D :: display()
{
cout << "a = " << get_a() << "\n";
cout << "b = " << b << "\n";
cout << "c = " << c << "\n\n";
}
//-------------------------------------------
int main()
{
D d;
d.get_ab();
d.mul();
d.show_a();
d.display();
d.b = 20;
d.mul();
d.display();
getch ();
return 0;
}
//clase base virtual
#include <iostream>
#include <conio.h>
#include <stdio.h>
using namespace std;
class estudiante
{
protected:
int roll_number;
public:
void get_number(int a)
{
roll_number = a;
}
void put_number(void)
{
cout << "Num lista: " << roll_number << "\n";
}
};
class test : virtual public estudiante
{
protected:
float part1, part2;
public:
void get_marks(float x, float y)
{
part1 = x; part2 = y;
}
void put_marks(void)
{
cout << "Puntuaciones obtenidas: " << "\n"
<< "parte1 = " << part1 << "\n"
<< "parte2 = " << part2 << "\n";
}
};
class deportes : public virtual estudiante
{
protected:
float score;
public:
void get_score(float s)
{
score = s;
}
void put_score(void)
{
cout << "Peso Deportes: " << score << "\n\n";
}
};
class resultado : public test, public deportes
{
float total;
public:
void display(void);
};
void resultado :: display(void)
{
total = part1 + part2 + score;put_number();
put_marks();
put_score();
cout << "Puntuacion Total: " << total << "\n";
}int main ()
{
resultado estudiante_1;
estudiante_1.get_number(678);
estudiante_1.get_marks(30.5, 25.5);
estudiante_1.get_score(7.0);
estudiante_1.display();
getch ();
return 0;
}
El programa 8.1 muestra una clase B y una clase derivada D. La clase B contiene un miembro de clases privado, un miembro de datos publico y tres funciones miembro publicas. La clase D contiene un miembro de datos privado y dos funciones miembro publicas.
HERENCIA SIMPLE PRIVADA:
Los miembros publicos de la clase base se convierten en miembros de la seccion private de la clase derivada. Por tanto los objetos de D no pueden tener acceso directo a las funciones miembro publicas de B.
Las sentencias tales como:
d.get_ab(); //get_ab() es privada
d.get_a(); //y tambien get_a()
d.show_a(); //y show_a()
una clase derivada con herencia multiple se declara de este modo:
abuelo
A
clase base
padre
B
Clase base
intermedia
hijo
C
clase derivada
class A{....}; //clase base
clase B: public A{....}; //B se derivada de A
clase C: public B{....}; //C se deriva de B
//HERENCIA MULTINIVEL
#include <iostream>
#include <conio.h>
using namespace std;
lass estudiante
{
protected:
int roll_number;
public:
void get_number(int);
void put_number(void);
}
void estudiante :: get_number(int a)
{
roll_number =a;
}
void estudiante :: put_number()
{
cout <<"Número lista: " << roll_number <<"\n";
}
class test : public estudiante //Derivación de primer nivel
{
protected:
float sub1;
float sub2;
public:
void get_marks(float,float)
void put_marks(void);
};
void test :: get_marks (float x, float y)
{
sub1=x;
sub2=y;
}
void test :: put_marks()
{
cout << "Puntuacion en SUB1= " << sub1 << "\n";
cout << "Puntuacion en SUB2= " << sub2 << "\n";
}
class resultado : public test // Derivación de segundo nivel
{
float total; // privado por defecto
public:
void display(void);
};
void resultado :: display(void)
{
total=sub1+sub2;
put_number();
put_marks();
cout <<"Total=" <<total << "\n";
}
int main()
{
resultado estudiante1; //Crea estudiante1
estudiante1.get_number(111);
estudiante1.get_marks(75.00, 59.5);
estudiante1.display();
getch ();
return 0;
}
Cuando se crea un objeto de una clase derivada, primero se invoca
al constructor de la clase o clases base y a continuación al
constructor de la clase derivada. Si la clase base es a su vez una clase derivada, el proceso se repite recursivamente.
Lógicamente, si no hemos definido los constructores de las clases,
se usan los constructores por defecto que crea el compilador.
¿COMO SE LE PASAN A LOS CONSTRUCTORES DE LA CLASE BASE PARA QUE HAGAN SU TRABAJO? C++ SOPORTA UN MECANISMO ESPECIAL DE PASO DE ARGUMENTOS PARA EESTAS SITUACIONES.
EL CONSTRUCTOR DE LA CLASE DERIVADA RECIBE LA LISTA COMPLETA DE VALORES COMO ARGUMENTOS PROPIOS, Y LOS PASA A LOS CONSTRUCTORES DE LA CLASE BASE EN EL ORDEN EN EL QUE ESTAN DECLARADOS EN LA CLASE DERIVADA.
LOS CONSTRUCTORES DE LA CLASE BASE SON LLAMADOS Y EJECUTADOS DE EJECUTAR LAS SENTENCIAS DEL CUERPO DEL CONSTRUCTOR DERIVADO.
//CONSTRUCTORES CLASE DERIVADA
#include <iostream>
#include <conio.h>
#include <stdio.h>using namespace std;class alfa
{
int x;
public:
alfa(int i)
{
x = i;
cout << "alfa inicializado \n";
}
void show_x(void)
{ cout << "x =" << x << "\n";}
};
class beta
{
float y;
public:
beta (float j)
{ y = j;
cout << "beta inicializado \n";
}
void show_y(void)
{ cout << "y = " << y << "\n";}
}; class gamma: public beta, public alfa
{
int m, n;
public:
gamma(int a, float b, int c, int d):
alfa(a), beta (b)
{
m = c;
n = d;
cout << "gamma inicializado \n";
}
void show_mn(void)
{
cout << "m =" << m << "\n"
<< "n =" << n << "\n";
}
};
int main()
{
gamma g(5, 10.75, 20, 30);
cout << "\n";
g.show_x();
g.show_y();
g.show_mn();
getch ();
return 0;
}
La herencia multiple nos permite combinar las caracteristicas de varias clases existentes como punto de partida para definir nuevas clases.
la sintaxis de una clase derivada con varias clases base es la siguiente:
class D: visibilidad B-1, visibilidad B-2....
{
........
........(cuerpo de D)
........
};
donde visibilidad puede ser public o private. las clases base estan separadas por comas.
por ejemplo:
class P: public M, public N
{
public:
void display (void);
};
CLASES MIEMBROS: ANIDACIÓN DE CLASES
LA HERENCIA ES EL MECANISMO QUE PERMITE DERIVAR CIERTAS PROPIEDADES DE UNA CLASE A OTRA.
C++ SOPORTA TAMBIEN OTRO MODO DE HEREDAR PROPIEDADES DE UNA CLASE A OTRA. ESTE ENFOQUE USA EL PUNTO DE VISTA DE QUE UN OBJETO PUEDE CONSTAR DE UNA COLECCION DE OTROS MUCHOS OBJETOS.
class alfa {....};
class beta{....};
class gamma
{
alfa a; //a es un objeto de la clase alfa
beta b; // b es un objeto de la clase beta
......
};
HERENCIA JERARQUICA
//LISTA DE INICIALIZACION EN LOS CONSTRUCTORES#include <iostream>#include <conio.h>#include <stdio.h>using namespace std;class alfa{int x;public:alfa(int i){x = i;cout << "\n alfa construido";}void show_alfa(void){cout << " x = " << x << "\n";}};class beta{float p, q;public:beta(float a, float b): p(a), q(b+p){cout << "\n beta construido";}void show_beta(void){cout << " p = " << p << "\n";cout << " q = " << q << "\n";}};class gamma : public beta, public alfa{int u, v;public:gamma(int a, int b, float c):alfa(a*2), beta(c,c), u(a){ v = b; cout << "\n gamma construido";}void show_gamma(void){cout << " u = " << u << "\n";
cout << " v = " << v << "\n";}};int main(){gamma g(2, 4, 2.5);cout << "\n\n Mostrar valores miembros " << "\n\n";g.show_alfa();g.show_beta();g.show_gamma();getch ();return 0;}
UN PROBLEMA SE CONVIERTE EN JERARQUIA CUANDO CIERTAS CARACTERISTICAS DE UN NIVEL SON COMPARTIDAS EN MUCHOS OTROS NIVELES INFERIORES.