Ich habe Probleme, einen gemeinsam genutzten Speicherpuffer zu implementieren, ohne die strengen Aliasing-Regeln von C99 zu verletzen.

Angenommen, ich habe einen Code, der einige Daten verarbeitet und einen Arbeitsspeicher benötigt, um zu funktionieren. Ich könnte es so etwas wie schreiben:

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

Dann habe ich eine andere Funktion, die einige andere Sachen macht, die auch einen Arbeitspuffer benötigen:

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

Das Problem ist, dass foo () und bar () während des Betriebs oft aufgerufen werden können und Heap-Zuordnungen überall ziemlich schlecht in Bezug auf Leistung und Speicherfragmentierung sein können. Eine naheliegende Lösung wäre, einen gemeinsamen, gemeinsam genutzten Speicherpuffer mit der richtigen Größe einmal zuzuweisen und ihn dann als Argument im BYOB-Stil an foo () und bar () zu übergeben:

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!
  // ...
}

Ich denke, ich habe jetzt zwei Fragen:
Kann ich einen gemeinsamen Arbeitsspeicherpuffer implementieren, der nicht gegen Aliasing-Regeln verstößt?
- Obwohl der obige Code strenge Aliasing-Regeln verletzt, wird mit dem Alias ​​kein "Schaden" angerichtet. Könnte ein vernünftiger Compiler (optimierten) Code generieren, der mich immer noch in Schwierigkeiten bringt?

Vielen Dank