Mensajes

[pos]

Puedes optimizar un poco el código, como ves pos siempre se incrementa, por lo que lo podrías sacar de los ifs.
Ya que el bucle principal recorre todos los caracteres del array mejor si solo manejas el control de los caracteres dentro de él y no generas más bucles, aparte de redundantes te quitan control y complican la lógica.
Te será más fácil si llevas todas las letras a minúsculas y ya fuera del bucle haces mayúscula la primera letra.
Ya existen funciones de librería para saber si un carácter es un carácter blanco y para cambiar la capitalización (solo en caracteres ingleses).

La idea es buena, pero vamos a ver los fallos.
Creas un array dinámico para alojar la inversa del array que pasas y te mueves en él mediante aritmética de punteros, haciendo que el puntero mismo vaya variando. Cuándo lo quieres liberar con delete has perdido el puntero original que apunta al inicio de bloque con lo que fallas. La solución es crear un puntero permanente que guarde esa posición y usar otro para moverte por el array, tal que así:

Código (cpp) [Seleccionar] Expandir


arrayPtr2 = new int[size];
arrayPtr2pointer = arrayPtr2;

Ahora usas uno para moverte como te movías y el otro para liberar con delete.

Para llevar arrayPtr hasta el final hazlo con una simple operación, así quitas código y tiempo de proceso:
En vez de

Código (cpp) [Seleccionar] Expandir


if (i == 0)
   for (int j = 0; j < size; j++)
       arrayPtr++;
usa

Código (cpp) [Seleccionar] Expandir

arrayPtr += size-1;

La orden para eliminar un array es mediante

Código (cpp) [Seleccionar] Expandir

delete [] identificardor_de_array y no con

Código (cpp) [Seleccionar] Expandir

delete identificador_de_array

Las órdenes para preparar el array arrayPtr y para realizar la copia del arrayPtr2 al arrayPtr sácalas del bucle de generación del arrayPtr2. Son trabajos diferentes.

La función debería quedarte algo como esto:

Código (cpp) [Seleccionar] Expandir


void reverse(int *arrayPtr, int size) {
   int *arrayPtr2pointer = new int[size];
   int *arrayPtr2 = arrayPtr2pointer;

   arrayPtr += size - 1;
   for (int i = 0; i < size; i++) {                
       *arrayPtr2 = *arrayPtr;
       arrayPtr--;
       arrayPtr2++;
   }

   arrayPtr++;  // Necesario porque en el último bucle se actualizan estos dos punteros
   arrayPtr2--;  // y sobrepasan los limites. Hay que regresarlos a su lugar.

   arrayPtr2 = arrayPtr2pointer;
   for (int i = 0; i < size; i++) {
       *arrayPtr = *arrayPtr2;
       arrayPtr++;
       arrayPtr2++;
   }
   delete [] arrayPtr2pointer;
}

Si la función no es para estudiar punteros, ni memoria dinámica y es solamente para invertir un array puedes dejar a un lado todo esto y usar código más normal.

Incluye en tu código lo siguiente:

Código (c) [Seleccionar] Expandir


#define SWAP(X,Y) { \
   (X) ^= (Y); \
   (Y) ^= (X); \
   (X) ^= (Y); \
}

#define ARRAY_LENGTH(X) sizeof(X)/sizeof(X[0])

void reverse(int array[], size_t size) {
   int i;
   for(i = 0; i < size / 2; ++i) {
       SWAP(array[i], array[size - i - 1]);
   }
}

Pero la ruta la puedes escribir directamente y no tener que ir trozo a trozo. Así podrias usar hasta las rutas relativas y el programa en script msdos o de powershell.

[code=cpp]

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?