Preguntas sobre la herencias.

[anonimo12121]

Mis pregunta son: ¿La herencia sirve para crear más instancias mientras esta en ejecución?, pondré el ejemplo de una ventana.

Tengo una ventana que tiene un botón llamado "crear ventana" al darle aparece otra igual.
¿Es eso?.

Ejemplo en código.

Código (cpp) [Seleccionar] Expandir

class Ventana {
   public:
       int x;
};
class V : public Ventana{
   public:
       void Create();
};
void V::Create(){
   V newv;
}
Me podrían decir como es?, es que no me entero.

Buen Rollo ;!

[avesudra]

La herencia sirve para crear nuevas clases a partir de otras , y la nueva contiene las mismas características que la primera más algún añadido.
Por ejemplo tenemos una clase vehículo rodante , que tiene una serie de funciones miembro , variables etc

Código (cpp) [Seleccionar] Expandir

class VehiculoRodante
{
public:
// CICLO DE VIDA
/* En este lugar se sitúan los constructores, los destructores, y/o los constructores copia */

// OPERADORES
/* Aquí van los métodos que se apliquen sobre operadores */

// OPERACIONES
/* Aquí van los métodos de esta clase que no sean ni de acceso ni de petición o tratamiento */

/*
* Función 'set_ruedas'
* Recibe: num como int
* Devuelve: void
* Asigna al dato miembro 'mRuedas' el valor 'num'
*/
void set_ruedas(int num)
{
 this->mRuedas = num;
}

/*
* Función 'get_ruedas'
* Recibe: void
* Devuelve: int
* Devuelve el valor que hay dentro del dato miembro 'mRuedas'
*/
int get_ruedas(void)
{
 return this->mRuedas;
}

/*
* Función 'set_pasajeros'
* Recibe: num como int
* Devuelve: void
* Asigna al dato miembro 'mPasajeros' el valor 'num'
*/
void set_pasajeros(int num)
{
 this->mPasajeros = num;
}

/*
* Función 'get_pasajeros'
* Recibe: void
* Devuelve: int
* Devuelve el valor que hay dentro del dato miembro 'mPasajeros'
*/
int get_pasajeros(void)
{
 return this->mPasajeros;
}

// PETICIONES/TRATAMIENTOS
/* Aquí van las funciones del tipo "Is", que generalmente devuelven true/false */

private:
/* Generalmente en 'private' se sitúan los datos miembros */
int mRuedas;
int mPasajeros;
Ahora podemos realizar la herencia de esta clase creando una subclase que contendrá lo anterior mas lo añadido:

Código (cpp) [Seleccionar] Expandir

class Camion : public VehiculoRodante
{

public:
// CICLO DE VIDA
/* En este lugar se sitúan los constructores, los destructores, y/o los constructores copia */

// OPERADORES
/* Aquí van los métodos que se apliquen sobre operadores */

// OPERACIONES
/* Aquí van los métodos de esta clase que no sean ni de acceso ni de petición o tratamiento */

// ACCESO
/* Aquí van las funciones de acceso a los datos miembro o variables propias del objeto */

/*
* Función 'set_carga'
* Recibe: size como int
* Devuelve: void
* Asigna al dato miembro 'mCarga' el valor 'size'
*/
void set_carga(int size)
{
 this->mCarga = size;
}

/*
* Función 'get_carga'
* Recibe: void
* Devuelve: int
* Devuelve el valor que hay dentro del dato miembro 'mCarga'
*/
int get_carga(void)
{
 return this->mCarga;
}


/*
* Función 'Mostrar'
* Recibe: void
* Devuelve: void
* Muestra por pantalla las ruedas, pasajeros y la capacidad de carga del objeto 'Camion'
*/
void Mostrar(void);

// PETICIONES/TRATAMIENTOS
/* Aquí van las funciones del tipo "Is", que generalmente devuelven true/false */

private:
/* Generalmente en 'private' se sitúan los datos miembros */
int mCarga;
};
Entonces este code por ejemplo:

Código (cpp) [Seleccionar] Expandir

int main(void)
{
 Camion Camion1;
 Camion Camion2;


 Camion1.set_ruedas(18);    //Accede a la funcion miembro de la clase vehiculorodante pero estamos en una clase heredada de ella Camion1.
 Camion1.set_pasajeros(2);
 Camion1.set_carga(3200);

 Camion2.set_ruedas(6);
 Camion2.set_pasajeros(3);
 Camion2.set_carga(1200);
 return 0;
}

[DarK_FirefoX]

Exactamente como dice avesadura, la herencia es un concepto muy util. Donde puedes crear clases a partir de clases ya existentes, estas clases nuevas "Heredan" del padres, todas las propiedades, metodos, variables publicas. Siempre y cuando esten configuradas para su acceso publico. Esto es muy util para crear jerarquias en un problema en especifico donde tengas funcionalidades en una clase que quieras añadir a otras clases sin tener que volverlas a programar. Salu2s

[anonimo12121]

Pues no se que co ño me esta explicando un colega.

Código (cpp) [Seleccionar] Expandir

class enemy{
    public:
        void move(...);
        void draw(...);
    private:
        int pos;
};

class zombie : enemy zombie{
    public:
        zombie(int);
        void SetMove(int);
};

zombie::zombie(int x){
    for(int i=0;i<x;i++){
        zombie a[i];
    }
}
zombie::SetMove(int x){
    zombie[x].Move(...);
}

[avesudra]

No entiendo el código , lo más lógico , es que la clase enemy , tuviera la posición , la función para dibujar y para mover al enemigo , y después la clase heredada lo feo que es el zombi , la vida que tiene , cual es el daño que provoca, a que velocidad corre...

En resumen , en el padre , las funciones y variables miembro PRINCIPALES de un enemigo , y sus clases heredadas las especificas de tales enemigos.

[DarK_FirefoX]

Exactamente lo que dice avesadura. Por ejemplo la clase enemy debe tener elementos que tengan los enemigos. De echo, no se debe poder crear una instancia de la clase enemy (no se como se llama en C++/C, pero en C# se llama abstract). Entocnes seguimos, la clase zombie al heredar de enemy tendra todas estos metodos y variables, y ademas le puedes agraegar los elementos propios de un zombie. Por ejemplo, si crearas otro enemigo, que sea bad_dog, este tambien heredara de enemy, luego este tendra las mismas cosas que la clase enemy y igualmente le podras agregar nuevas funcionalidades..¿entendiste?

[anonimo12121]

Lo que entiendo es lo que heredan lo que no entiendo son las declaraciones de este mismo code que os puedo.

Se puede hacer que mientras el programa este activo pueda declarar clases?

[avesudra]

A ver a ver yo tampoco entiendo el code podria estar comentado o algo de eso porque imaginarme lo que es no puedo.En cuanto a lo de que el programa esté activo declarar clases, ¿puedes declarar variables cuando el programa está activo?¿Puedes declarar estructuras cuando el programa está activo? Pues lo mismo con las clases.Código de ejemplo:

Código (cpp) [Seleccionar] Expandir

#include<iostream>
class chucho
{
public:
void lamer();
void comer();
void dormir();
};
int main() //Aqui el programa ya esta activo
{
   int variable_creada=0; //Podemos declarar una variable.
   if(variable_creada==1) //O no hacerlo
   {
      int variable2;          //Es creada si variable_creada es igual que uno
   }
   //Si no no la creamos del mismo modo podemos declarar clases.
  chucho yorkshire;
  chucho pastor_aleman;
  chucho dalmata;
}

[anonimo12121]

No ya, era una rallada total lo que tenia culpa de mi amigo. entiendo la herencia pero es que el me estaba contando un cosa muy rara. Gracias Avesudra