Obviamente, debes conocer las diferencias de tamaños para decidir si una union es buena idea o no, y saber si realmente necesitas ese almacenamiento. En ESTA situación, cualquier uso de uniones es DISPARATADO 

¿Porqué?
Porque cuando aún no sabes si es un médico o un paciente, usas el flag para tratarlo. Entonces ¿realmente necesitas almacenar las estructuras en un espacio de memoria común? Sin importar el tipo, puedes tener dos funciónes diferentes, con lo que la función que hace de dispatcher, no tiene que hacer más que pasar el puntero a quien le corresponda... que me parece mucho más razonable  , y si quieres probar si es NULL, lo haces al principio, cosa que te quedaría como:

void
funcion_dispatcher(void *puntero, tipo_dispatcher flag) {
    if (!puntero)
        muere("funcion_dispatcher: puntero nulo!");
 
    switch (flag) {
        case esMedico:
            funcionMedico((struct medico*)puntero);
            break;
        case esPaciente:
            funcionPaciente((struct paciente*)puntero);
            break;
    }
}

O lo que me parece más visible/lindo:

void
funcion_dispatcher(void *puntero, tipo_dispatcher flag) {
    if (!puntero)
        muere("funcion_dispatcher: puntero nulo!");
 
    if (flag == esMedico)
            funcionMedico((struct medico*)puntero);
 
    if (flag == esPaciente)
            funcionPaciente((struct paciente*)puntero);
}

No había visto lo de los punteros. Pero no quita lo que decía, porque usar un "union" donde siempre se usará un puntero, y acceder luego a sus miembros es a fin de cuentas... un casteo. Y si vamos a hacer un casteo es mejor ser explícitos.

Por otro lado, no están más relacionados de lo que significa pasar por un mismo dispatcher, porque al final serán tratados por funciónes diferentes. Como al fin y al cabo, usas el union para "castear" el puntero contenido en ese espacio de memoria (el union)...

switch(p.flag){
    case f_medico:
         //lo manejo como medico
        handleMedico(m.data.m);
        break;
    case f_paciente:
         //lo manejo como paciente
        handlePaciente(m.data.p);
        break;
}

...entonces resulta más legible ir al grano con un cast. A demás, al usar esta forma tienes dos problemas a tener en cuenta:

1 - Necesitas una variable extra en la pila local de la función... solo a fin de alojar el puntero que te llega por parámetro, y para enviarlo a otra función. Es innecesario.
2 - Si declaras desde el main los datos como instancias de la union para evitar las variables locales innecesarias, pierdes la posibilidad de tener flujos donde se manejen solo pacientes, o solo médicos (en el ejemplo), sin pasar previamente por un dispatcher. Si los dispatchers son siempre necesarios, es porque tienes dos flujos separados. Seguramente perderás más de dos bytes haciendo dispatchers para cada flujo, y es la diferencia entre crear una instancia de cada tipo, y una union.

Si se desea castear un puntero, entonces se usa un cast, solo por mantener el código simple.

Saludos

Una cosa, que me he liado, entonces que sería mas optimo hacer el cast directamente o hacer lo que propone pucheto mediante uniones y estructuras.

Un saludo y gracias por las respuestas.

Dependiendo el problema depende que solución es mas aceptable, y esto ultimo siempre va a ser subjetivo. Personalmente para este caso en particular me parece mas correcta la idea de Pucheto que hacer un cast directo. Tal vez las ventajas del planteo de Pucheto no son tan visibles en 10 lineas pero se notarían si tenes que ponerte al día en un proyecto relativamente extenso y encima mantenerlo, aunque esto por supuesto depende de cada uno.

Saludos

Esto ya es un mareo. A ver:

Supongo que será por lo relativo, pero yo, siendo nuevo en un proyecto, preferiría mil veces encontrar esto:

    if (flag == esMedico)
            funcionMedico((struct medico*)puntero);
 
    if (flag == esPaciente)
            funcionPaciente((struct paciente*)puntero);

que es explícito en lo que hace, y no esto:

    case f_medico:
        //lo manejo como medico
        handleMedico(m.data.m);
        break;
    case f_paciente:
        //lo manejo como paciente
        handlePaciente(m.data.p);
        break;

que es como... poco claro, a mi parecer.


Si no lo entiendo mal, recibes un puntero en la función, y haces algo como:

void
funcion(void *punt ...) {
    personaHospital p = (personaHospital) *punt; /* algo asi, que requiere una variable local p, o un puntero */
 
    switch(p.flag){
        case f_medico:
            //lo manejo como medico
            handleMedico(m.data.m);
            break;
        case f_paciente:
            //lo manejo como paciente
            handlePaciente(m.data.p);
            break;
    }
}
 

Que no era necesaria sin la union...

Creo que nunca se manejarían "por igual"... si tuvieran miembros en común que se manejen por igual, entonces metería algo como herencia. Una estructura compartida entre ambos al inicio de la estructura de cada uno. Y así los despachos con un único puntero siguen siendo válidos, aunque en realidad habrá código compartido tanto como código para cada implementación.

Estamos tratando de dar solución a ningún problema, creo que eso es lo más confuso 

Muestrame el código que pondrías para darme una mejor idea de tu idea.

Saludos