Die Implementierung eines generical 'anzeigen' - Funktion über arrays in C

Ihre erste problem ist, dass du tust viel zu viel in ein paar Ausdrücke. Sie müssen, um es zu brechen.

void MapArray(void * src, void * dest, void * (f)(void *), size_t n, size_t elem)
{
   unsigned int i = 0, j = 0;
   void * temp = malloc(elem);

   char* csrc = (char*)src;
   char* cdest = (char*)dest;
   char* ctemp = (char*)temp;
   for(i = 0; i<n; i++)
   {
       csrc++;
       cdest++;
       ctemp++;
       temp = f(csrc);
       for(j = 0; j < elem; j++)
       {
           cdest[i] = ctemp[i];
       }
   }
   free(temp);
}

Nun Ihre zweite problem. Sie malloc ein Puffer, dann Sie .. zuweisen, die Zeiger? Wiederholt? Dann frei, nur die letzten f-call ist das Ergebnis? Das ist völlig unnötig.

void MapArray(void * src, void * dest, void * (f)(void *), size_t n, size_t elem)
{
   unsigned int i = 0, j = 0;

   char* csrc = (char*)src;
   char* cdest = (char*)dest;
   for(i = 0; i<n; i++)
   {
       csrc++;
       cdest++;
       char* ctemp = (char*)f(csrc);
       for(j = 0; j < elem; j++)
       {
           cdest[i] = ctemp[i];
       }
   }
}

Nun Ihre Dritte problem. Übergeben Sie einen Zeiger -, sondern nur zu verkohlen. Sie don ' T-pass in ein void*. Dies bedeutet, dass Ihre Funktion nicht generisch sein - f nicht angewendet werden, zu nichts. Wir brauchen ein array von void*s, so dass die Funktion beliebigen Typs als argument. Wir müssen auch die Größe des Typs als argument, so dass wir wissen, wie weit zu bewegen entlang dest.

void MapArray(void ** src, void * dest, void * (f)(void *), size_t n, size_t sizeofT)
{
    for(unsigned int i = 0; i < n; i++) {
        void* temp = f(src[n]);
        memcpy(dest, temp, sizeofT);
        dest = (char*)dest + sizeofT;
    }
}

Wir haben noch ein anderes problem - der Speicher temp. Wir nicht frei. Noch geben wir eine Benutzer-Daten-argument in f, die ihm erlauben würde, zurück heap-Speicher reserviert, den wir nicht brauchen, frei zu sein. Der einzige Weg, in die f arbeiten können, ist, wenn es wieder einen statischen Puffer.

void MapArray(void ** src, void * dest, void * (f)(void *, void*), void* userdata, size_t n, size_t sizeofT)
{
    for(unsigned int i = 0; i < n; i++) {
        void* temp = f(src[n], userdata);
        memcpy(dest, temp, sizeofT);
        dest = (char*)dest + sizeofT;
    }
}

Nun f kann auf so ziemlich, was er will und halten, was Staat es braucht. Aber wir noch nicht freie Puffer. Nun, f gibt eine einfache Struktur, die uns sagt, wenn wir brauchen, um das gratis-Puffer. Dies ermöglicht auch uns, frei oder nicht frei, den Puffer auf verschiedene Aufrufe von f.

typedef struct {
    void* data;
    int free;
} freturn;

void MapArray(void ** src, void * dest, freturn (f)(void *, void*), void* userdata, size_t n, size_t sizeofT)
{
    for(unsigned int i = 0; i < n; i++) {
        freturn thisreturn = f(src[n], userdata);
        void* temp = thisreturn.data;
        memcpy(dest, temp, sizeofT);
        dest = (char*)dest + sizeofT;
        if (thisreturn.free)
            free(temp);
    }
}

Allerdings bin ich immer noch nicht verstehen, den Zweck dieser Funktion. All das ersetzen einer einfachen for-Schleife? Der code, den Sie versuchen zu ersetzen ist einfacher, als den code die Funktion aufrufen, und wahrscheinlich effizienter, und definitiv stärker (Sie können fortfahren/Pause, zum Beispiel).

Mehr als das, C saugt wirklich für diese Art von Arbeit. C++ ist viel besser. Es ist ziemlich trivial, es zur Anwendung einer Funktion auf jedes Element eines Arrays, zum Beispiel.

InformationsquelleAutor Puppy

• Überprüfen Sie, dass die Funktion f ist nicht Rückgabe einen Zeiger auf eine lokale variable
• Ich bin nicht sicher, was die Schleife über j ist eigentlich

InformationsquelleAutor srean