Estupendo.
Ahora tienes que resolver dos cosas:
1. Como recibes un coche y lo despachas en 10 minutos, al siguiente turno, no hay nunca una cola llena. Puedes hacer que un vehículo tarde, almenos 20 minutos (2 turnos en ser despachado) o, mejor aun, que cada tipo de vehículos tenga un tiempo diferente.

2. Prescindir de queue y hacerlo todo a mano como has aprendido.

Una cosa más. Cuando insertes código selecciónalo, ve al desplegable GeSHi y selecciona el lenguaje con que lo has escrito. Debería rodearse entre dos etiquetas BBS [code=cpp] y [/code] (también puedes escribirlas a mano).

No deja implementar librerías de colas,  porqué tendrás que hacerlas tú, pero las otras seguro que sí.
Crea un struct, o clase, que pueda guardar los datos que han dicho y prepárala para que sea un miembro de una cola.
Crea 4 punteros diferentes para soportar sendas colas. Si ya has trabajado con ellas no será difícil manejarlas.
En main genera un número aleatorio entre el 0 y el 3 a.i. y según lo que salga generas un vehículo u otro  y lo encolas. Al mismo tiempo liberas el último elemento de una de las colas, por ejemplo el vehículo que más tiempo lleva esperando.
Mediante funciones time haces un segundo de espera y repites todo el proceso.

Podría poner una opción para salir si no se quisiera marcar un fabricante o uno de los productos en posterioridad. Pero ya es muy tarde, las 2 de la mañana  .
Eso sí, el programa te dejará seguir si eliges una opción correcta.

No es infinito. Pruébalo

No entiendo esa afirmación

La cosa es que si intentas acceder a un puntero liberado por free, pero que no se ha llevado a NULL, nadie se va a quejar y el programa puede seguir corriendo y puedes ver los efectos de una cascada de errores más adelante, difícil de depurar si el error se ha ido transmitiendo bastante lejos. Pero si llevas a NULL el puntero, al siguiente acceso que hagas a él para escribir te tirará error con lo que ya sabrás que ese puntero se ha liberado antes de lo previsto, así puedes localizar el error con más precisión.

Y digo yo: y si en vez de usar malloc y después un for para recorrer la tabla y ponerla a 0, ¿porqué no usas calloc y haces todo el trabajo de una tacada?

En verdad C es de por sí inseguro y solo le interesa la velocidad y la libertad del programador. A parte del ensamblador es, seguramente, el lenguaje más libre_de_hacer_lo_que_quieras que haya circulando por el mundo.
Es como un gran muscle car sin control de derrape, ni abs, ni de tracción activa: o eres un buen piloto o no le sacas todo el partido al coche o, peor aún, te estrellas.

Lástima que el trabajo sea en C++, porqué sé muy poco de ese lenguaje, pero aquí te enseño un código en C el cuál tienes los datos separados de la lógica, una función menú genérica y un main limpio.

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
 
/* Estas tablas facilitan los posteriores cambios en las opciones */
/* En las opciones de menú poner siempre al final un NULL, ya que
 * es lo que espera la función para trabajar con estos argumentos.
 */
const char *fabricantes[] = {"Microsoft", "Apple", "Linux", NULL};
const char *productos[] = {"Sistema operativo", "Lenguaje de programación", NULL};
const char *dispositivo[] = {"Celulares", "Tablas", "Otros", NULL};
 
const int precios_microsoft[] = {
            /* Sistema operativo */ 1500,
            /* Lenguaje de Programación */
            /*    Celulares */      1800,
            /*    Tablas    */      1200,
            /*    Otros     */       900};
 
const int precios_apple[] = {
            /* Sistema operativo */ 2500,
            /* Lenguaje de Programación */
            /*    Celulares */      1900,
            /*    Tablas    */      1800,
            /*    Otros     */      1600};
 
const int precios_linux[] = {
            /* Sistema operativo */ 1000,
            /* Lenguaje de Programación */
            /*    Celulares */       100,
            /*    Tablas    */       150,
            /*    Otros     */        50};
 
int menu(const char *titulo, const char *empresa, const char **opciones) {
    int i = 0;
    int respuesta;
 
    do {
        /* Imprimiendo el título del menú */
        printf("%s ", titulo);
        if(empresa)
            printf("%s", empresa);
        printf(":\n\n");
        /* Imprimiendo opciones del menú */
        while(opciones[i] != NULL) {
            printf("    %2i. %s\n", i + 1, opciones[i]);
            ++i;
        }
        --i;
        /* Adquiriendo la opción deseada */
        printf("\n    Opcion >> ");
        respuesta = getchar();
        /* Control de errores de la entrada por teclado */
        while(getchar() != '\n');
        if(isdigit(respuesta))
            respuesta -= '0' + 1;
        else
            respuesta = -1;
        if(respuesta > i)
            respuesta = -1;
        if(respuesta == -1) {
            i = 0;
            printf("*** OPCION INCORRECTA ***\n");
            while(getchar() != '\n');
        }
    } while(respuesta == -1);
 
    /* Un poco bonito, que también puede formar parte del menú... */
    putchar('\n');
 
    /* Devuelvo la opción elegida */
    return respuesta;
}
 
int main() {
    int respuesta;
    const char *fabricante;
    const int *lista_de_precios;
 
    respuesta = menu("Elija fabricante", NULL, fabricantes);
    fabricante = fabricantes[respuesta];
    switch(respuesta) {
        case 0:
            lista_de_precios = precios_microsoft;
            break;
        case 1:
            lista_de_precios = precios_apple;
            break;
        case 2:
            lista_de_precios = precios_linux;
            break;
    }
 
    respuesta = menu("Elija el producto de", fabricante, productos);
 
    if(respuesta == 1)
        respuesta = menu("Elija el dispositivo de", fabricante, dispositivo) + 1;
 
    printf("El precio del producto es: %i", lista_de_precios[respuesta]);
 
    return 0;
}

C++ y C a partir del estándar del 99 sí se puede declarar el array con variables.