Introducing 

Prezi AI.

Your new presentation assistant.

Refine, enhance, and tailor your content, source relevant images, and edit visuals quicker than ever before.

Loading…
Transcript

HERENCIA: EXTENSIÓN

DE CLASE

EQUIPO:

MARICELA SEGOVIA

JUANA ESTHER GONZALES

MARIBEL JIMENEZ

CINDY LINETH OLAN

ELSY BAUTISTA

#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

}:

HERENCIA HIBRIDA

DEFINICION DE CLASES DERIVADAS

ES DONDE SE NECESITA O SE PUEDE APLICAR DOS O MAS TIPOS DE HERENCIA PARA DISEÑAR UN PROGRAMA

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

......//

}:

CLASES BASE VIRTUALES

LAS CLASES BASE VIRTUALES SE GENERAN IMPLICANDO LOS 3 TIPOS DE HERENCIA;

ES DECIR MULTINIVEL, MULTIPLE Y JERARQUICA

COMO HEREDAR UN MIEMBRO PRIVADO

//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;

}

HERENCIA SIMPLE

C++ ofrece un tercer modificador de visiblidad, protected. un miembro declarado por protected es accesible para las funciones miembro dentro de una clase, y cualquier clase derivada inmediatamente de ella. las funciones que no permanezca a estas dos clases no pueden acceder a el. una clase puede usar los tres modos de visibilidad,como se muestra a continuacion:

class alfa

{

private: //opcional

..... //visible para funciones miembro

..... //dentro de una clase

protected:

...... //visible para funciones miembro

...... //de su clase y clases derivadas

public:

........ //visible para todas las funciones

........ //del programa

};

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()

CLASES ABSTRACTAS

ES UNA CLASE QUE NO SE UTILIZA PARA

CREAR OBJETOS. ESTA DISEÑADA SOLO

PARA ACTUAR COMO CLASE BASE (PARA

SER HEREDADA POR OTRAS CLASES).

HERENCIA MULTINIVEL

una clase derivada con herencia multiple se declara de este modo:

abuelo

A

clase base

padre

B

Clase base

intermedia

hijo

C

Las palabras reservadas private, protected y public pueden aparecer en cualquier orden y cualquier numero de veces en la declaracion de una clase. ejemplo:

class beta

{

protected:

.......

public:

..........

private:

.........

public:

........

};

es una definicion de clase valida.

clase derivada

class A{....}; //clase base

clase B: public A{....}; //B se derivada de A

clase C: public B{....}; //C se deriva de B

CONSTRUCTORES EN CLASES DERIVADAS

//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;

}

HERENCIA MULTIPLE

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

......

};

Todos los objetos de la clase gamma contendran los objetos a y b. Este tipo de relacion

se llama anidacion o inclusion. Esto consta de dos etapas

1.- se creean los objetos mienbros usando sus constructores respectivos, y

2.-se crean los restantes miembros ordinarios.

Es decir, los constructores de todos los objetos miembro tienen que ser llamados

antes de poder ejecutar el cuerpo del constructor.

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.

Learn more about creating dynamic, engaging presentations with Prezi