Implementieren von RAII in reinem C?

Question 1

Ist eine Umsetzung möglich RAII in reinem C?

Ich nehme an, es ist auf keine vernünftige Weise möglich, aber vielleicht ist es mit einer Art schmutzigem Trick möglich. Überlastung des Standards free Funktion in den Sinn kommt oder vielleicht die Rückgabeadresse auf dem Stack überschreiben, so dass, wenn die Funktion zurückkehrt, sie eine andere Funktion aufruft, die irgendwie Ressourcen freigibt? Oder vielleicht mit einem setjmp/longjmp-Trick?

Dies ist von rein akademischem Interesse und ich habe nicht die Absicht, solch einen nicht tragbaren und verrückten Code zu schreiben, aber ich frage mich, ob das überhaupt möglich ist.

Question 2

Dies ist inhärent implementierungsabhängig, da der Standard eine solche Möglichkeit nicht enthält. Für GCC ist die cleanup Das Attribut führt eine Funktion aus, wenn eine Variable den Gültigkeitsbereich verlässt:

#include <stdio.h>

void scoped(int * pvariable) {
    printf("variable (%d) goes out of scope\n", *pvariable);
}

int main(void) {
    printf("before scope\n");
    {
        int watched __attribute__((cleanup (scoped)));
        watched = 42;
    }
    printf("after scope\n");
}

Drucke:

before scope
variable (42) goes out of scope
after scope

Sehen hier

Question 3

Eine Lösung, um RAII auf C zu bringen (wenn Sie keine haben cleanup()) besteht darin, Ihren Funktionsaufruf mit Code zu umschließen, der eine Bereinigung durchführt. Dies kann auch in ein ordentliches Makro verpackt werden (am Ende gezeigt).

/* Publicly known method */
void SomeFunction() {
  /* Create raii object, which holds records of object pointers and a
     destruction method for that object (or null if not needed). */
  Raii raii;
  RaiiCreate(&raii);

  /* Call function implementation */
  SomeFunctionImpl(&raii);

  /* This method calls the destruction code for each object. */
  RaiiDestroyAll(&raii);
}

/* Hidden method that carries out implementation. */
void SomeFunctionImpl(Raii *raii) {
  MyStruct *object;
  MyStruct *eventually_destroyed_object;
  int *pretend_value;

  /* Create a MyStruct object, passing the destruction method for
     MyStruct objects. */
  object = RaiiAdd(raii, MyStructCreate(), MyStructDestroy);

  /* Create a MyStruct object (adding it to raii), which will later
     be removed before returning. */
  eventually_destroyed_object = RaiiAdd(raii,
      MyStructCreate(), MyStructDestroy);

  /* Create an int, passing a null destruction method. */
  pretend_value = RaiiAdd(raii, malloc(sizeof(int)), 0);

  /* ... implementation ... */

  /* Destroy object (calling destruction method). */
  RaiiDestroy(raii, eventually_destroyed_object);

  /* or ... */
  RaiiForgetAbout(raii, eventually_destroyed_object);
}

Sie können den gesamten Textbausteincode in ausdrücken SomeFunction mit Makros, da es bei jedem Anruf gleich ist.

Zum Beispiel:

/* Declares Matrix * MatrixMultiply(Matrix * first, Matrix * second, Network * network) */
RTN_RAII(Matrix *, MatrixMultiply, Matrix *, first, Matrix *, second, Network *, network, {
  Processor *processor = RaiiAdd(raii, ProcessorCreate(), ProcessorDestroy);
  Matrix *result = MatrixCreate();
  processor->multiply(result, first, second);
  return processor;
});

void SomeOtherCode(...) {
  /* ... */
  Matrix * result = MatrixMultiply(first, second, network);
  /* ... */
}

Hinweis: Sie sollten ein erweitertes Makro-Framework wie P99 verwenden, um so etwas wie das oben Gesagte zu ermöglichen.

Question 4

Wenn Ihr Compiler C99 (oder sogar einen wesentlichen Teil davon) unterstützt, können Sie ein Array mit variabler Länge (VLA) verwenden, wie zum Beispiel:

int f(int x) { 
    int vla[x];

    // ...
}

Wenn die Erinnerung dient, gcc hatte/unterstützte diese Funktion lange bevor sie zu C99 hinzugefügt wurde. Dies entspricht (ungefähr) dem einfachen Fall von:

int f(int x) { 
    int *vla=malloc(sizeof(int) *x);
    /* ... */
    free vla;
}

Sie können jedoch keine der anderen Dinge tun, die ein dtor tun kann, wie z. B. das Schließen von Dateien, Datenbankverbindungen usw.

Question 5

Der wahrscheinlich einfachste Weg ist, goto zu verwenden, um am Ende einer Funktion zu einem Label zu springen, aber das ist wahrscheinlich zu manuell für die Art von Dingen, die Sie sich ansehen.

Question 6

Ich würde mich dafür entscheiden, die Absenderadresse auf dem Stapel zu überschreiben. Es würde am transparentesten funktionieren. Ersetzen free funktioniert nur mit Heap-zugewiesenen “Objekten”.

Question 7

Hast du dir alloca() angeschaut? Es wird freigegeben, wenn eine Variable den Gültigkeitsbereich verlässt. Aber um es effektiv zu nutzen, muss der Aufrufer immer alloca ausführen, bevor er es an Dinge sendet … Wenn Sie strdup implementieren, nun, Sie können alloca nicht verwenden.

Question 8

Um diesen Teil von Johannes ‘Antwort zu ergänzen:

Das cleanup-Attribut führt eine Funktion aus, wenn eine Variable den Gültigkeitsbereich verlässt

Es gibt eine Einschränkung für das Bereinigungsattribut (http://gcc.gnu.org/onlinedocs/gcc-4.0.4/gcc/Variable-Attributes.html): Dieses Attribut kann nur auf Auto-Funktionsbereichsvariablen angewendet werden.

Wenn es also eine statische Variable in einer Datei gibt, ist es möglich, RAII für eine statische Variable auf diese Weise zu implementieren:

#include <stdio.h>
#include <stdlib.h>

static char* watched2;

__attribute__((constructor))
static void init_static_vars()
{
  printf("variable (%p) is initialazed, initial value (%p)\n", &watched2, watched2);
  watched2=malloc(1024);
}


__attribute__((destructor))
static void destroy_static_vars()
{
  printf("variable (%p), value( %p) goes out of scope\n", &watched2, watched2);
  free(watched2);
}

int main(void)
{
  printf("exit from main, variable (%p) value(%p) is static\n", &watched2, watched2);
  return 0;
}

Das ist ein Test:

>./example
variable (0x600aa0) is initialazed, initial value ((nil))
exit from main, variable (0x600aa0) value(0x16df010) is static
variable (0x600aa0), value( 0x16df010) goes out of scope