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

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:

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:

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

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

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(...);
}

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?

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:

#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;
}