Estoy luchando con la implementación de un búfer de memoria compartida sin romper las estrictas reglas de alias de C99.

Supongamos que tengo un código que procesa algunos datos y que necesita tener memoria de "cero" para funcionar. Podría escribirlo como algo así como:

void foo(... some arguments here ...) {
  int* scratchMem = new int[1000];   // Allocate.
  // Do stuff...
  delete[] scratchMem;  // Free.
}

Luego tengo otra función que hace otras cosas que también necesitan un buffer de memoria virtual:

void bar(...arguments...) {
  float* scratchMem = new float[1000];   // Allocate.
  // Do other stuff...
  delete[] scratchMem;  // Free.
}

El problema es que se puede llamar a foo () y bar () muchas veces durante la operación y tener asignaciones de almacenamiento dinámico por todas partes puede ser bastante malo en términos de rendimiento y fragmentación de la memoria. Una solución obvia sería asignar un búfer de memoria compartida común de tamaño adecuado una vez y luego pasarlo a foo () y bar () como un argumento, estilo BYOB:

void foo(void* scratchMem);
void bar(void* scratchMem);

int main() {
  const int iAmBigEnough = 5000;
  int* scratchMem = new int[iAmBigEnough];

  foo(scratchMem);
  bar(scratchMem);

  delete[] scratchMem;
  return 0;
}

void foo(void* scratchMem) {
  int* smem = (int*)scratchMem;
  // Dereferencing smem will break strict-aliasing rules!
  // ...
}

void bar(void* scratchMem) {
  float* smem = (float*)scratchMem;
  // Dereferencing smem will break strict-aliasing rules!
  // ...
}

Supongo que ahora tengo dos preguntas:
- ¿Cómo puedo implementar un búfer de memoria compartido común que no infrinja las reglas de alias?
- A pesar de que el código anterior viola las reglas estrictas de aliasing, no se hace ningún daño con el alias. Por lo tanto, ¿podría un compilador sano generar código (optimizado) que todavía me ponga en problemas?

Gracias