2. El proceso por el cuál se crea una nueva clase llamada clase derivada a partir de una clase llamada clase base. Sintaxis declaración: class clase_derivada: public|protected|private clase_base { // Declaración de datos y funciones miembro } HERENCIA
3. class persona { public: persona(); void leer_info(); void presentar_info(); void mensaje (); private: char nombre [50]; char ciudad [50]; } class alumno: public persona { public: alumno(); void leer_info(); double promedio(); void mensaje (char [] ); private: int notas[10]; }
4. TIPOS DE DERIVACIÓN Protected Protected Protected Public Inaccesible Private Protected Private Protected Private Public Inaccesible Private Private Protected Protected Public Public Inaccesible Private Public Acceso Clase Derivada Acceso Clase Base Tipo Derivación
5. class persona{ public: persona(); void leer_info(); protectec: char nombre [50]; private: int ciudad [10]: } class alumno: public persona { } class alumno: protected persona { } class alumno: private persona { } void main() { alumno d; d.leer_info(); d.nombre = “Juan”; d.ciudad = “Loja”; }
6. REDEFINIR FUNCIONES MIEMBRO Si se declara una función miembro en la clase derivada con el mismo nombre y firma que en la clase base, es necesario volver a redefinir esta función. void persona::leer_info() { cout <<”ingrese cedula” << endl; cint >> cedula; cout <<”ingrese nombre” << endl; cint >> nombre; cout <<”ingrese ciudad” << endl; cint >> ciudad; } void alumno::leer_info() { persona::leer_info(); int i; for (i=0; i<10; i++){ cout <<”ingrese notas”; cint >> notas[ i ];} }
7. CONSTRUTORES Y DESTRUCTORES Los constructores y destructores de la clase base no se heredan, deben escribirse en la clase derivada. persona::persona() { int i; for (i=0, i< 10, i++) { cedula[i] = 0 } } alumno::alumno(): persona::persona() { int i; for (i=0, i< 10, i++) { notas[i] = 0 } }
8. APUNTADORES Un apuntador es una variable que almacena la dirección de memoria. * sirve para declarar una variable apuntador. int *puntero; char *puntero1, *puntero2; & obtener la dirección de memoria. * permite acceder indirectamente al valor de la variable cuya dirección se almacena en un puntero.
10. ESTRUCTURAS Es un grupo de datos que pueden ser de distinto tipo de dato. Struct nombre { Declaración de miembros; } struct persona { char nombre[50]; char ciudad[50]; double salario; } void main() { persona pers1; cout << “ Ingrese Nombre: “; cin >> pers1.nombre; cout << pers1.nombre <<endl; }
11. APUNTADOR A UNA ESTRUCTURA Operador miembro apuntador -> se lo utiliza para acceder indirectamente a los miembros de una estructura. struct persona { char nombre[50]; char ciudad [50]; double salario; } void main() { persona pers1; persona *ptr_pers1; ptr_pers1 = &pers1; cout << “ Ingrese Nombre: “<<endl; cin >> pers1.nombre; cout << pers1.nombre <<endl; cout << ptr_pers1->nombre <<endl; }
12. -> LISTAS ENCADENADAS Es una lista de nodos en la cual por cada nodo se guardan los campos definidos en una estructura de datos, además debe el nodo tener un campo que apunte al nodo siguiente. struct persona { char nombre[50]; double salario; persona * enlace; } enlace salario nombre enlace salario nombre
13. CREAR PRIMER NODO Es siempre necesario guardar la dirección de memoria del primer nodo, para lo cual se crea un apuntador llamado cabeza o head. persona *cabeza; cabeza = new persona; strcpy(cabeza->nombre,“Juan”); cabeza ->salario = 565; cabeza->enlace = NULL; NULL 565 Juan
14. AGREGAR NODOS A UNA LISTA Para agregar un nodo al final de la lista es necesario trabajar con una variable cola para que guarde la dirección del último nodo de la lista. Si deseamos agregar un nuevo nodo, lo crearemos a partir del último nodo a cola cola->enlace = new persona;
15. void insertar (char nombre [ ], double salario){ if (cabeza == NULL){ cabeza = new persona; cola = cabeza;} else { cola->enlace = new persona; cola = cola->enlace;} strcpy(cola->nombre, nombre); cola->salario = salario; cola->enlace = NULL; } 1001 1002 1003 --> --> 1003 600 Ana NULL 480 Teresa 1002 565 Juan
16. RECORRIDO DE UNA LISTA Para recorrer una lista es necesario iniciar en la cabeza de la lista y avanzar hasta los siguientes nodos. presentar lista() { persona* aux = cabeza; while (aux != NULL){ aux = aux -> enlace; } } persona * aux; aux = cabeza; aux = aux ->enlace;
17. ELIMINACION DE NODOS Eliminar Cabeza persona * temp = cabeza; cabeza = cabeza->enlace 1001 1002 1003 1004 --> --> --> 1003 600 Ana 1004 480 Teresa 1002 565 Juan NULL 450 Pablo
19. Eliminación nodo diferente de cabeza void eliminarnodo(persona * pos){ persona * aux = pos->enlace; pos->enlace = pos->enlace->enlace; delete aux; } Función que recibe un nodo anterior al eliminar 1001 1002 1003 1004 --> --> --> Nodo a eliminar 1003 600 Ana 1004 480 Teresa 1002 565 Juan NULL 450 Pablo
20. void eliminarnodo(int n){ persona * pos = cabeza; while (i<n) || pos->enlace ==NULL){ pos = pos->enlace; i++; } if (pos== NULL) {cout <<”error” exit(0) } persona * aux = pos->enlace; pos->enlace = pos->enlace->enlace; delete aux; } Función que recibe la posición de nodo a eliminar
