C: Zeiger auf array von Zeigern auf Strukturen (allocation/deallocation Fragen)

Ich habe immer wieder in C für etwas, aber ich habe Probleme erinnern, wie sehr dieses Speicher-management funktioniert. Ich möchte einen Zeiger auf ein array von Zeigern auf Strukturen.

Sagen, ich habe:

struct Test {
   int data;
};

Dann das array:

struct Test **array1;

Ist das richtig? Mein Problem ist das arbeiten mit diesem Ding. Also jeder Zeiger in dem array zeigt auf etwas, zugewiesen ist, getrennt. Aber ich denke, ich brauche dazu zuerst:

array1 = malloc(MAX * sizeof(struct Test *));

Ich habe Schwierigkeiten zu verstehen, die oben genannten. Brauche ich, um dies zu tun, und warum muss ich dies tun? Insbesondere, was bedeutet es, Speicher für Zeiger, wenn ich dabei bin, werden allokierung von Speicher für jede Sache, die der Zeiger zeigt?

Sagen, jetzt habe ich Zeiger auf ein array von Zeigern auf Strukturen. Ich möchte nun diese auf das gleiche array, dass ich zuvor erstellt haben.

struct Test **array2;

Brauche ich um zu reservieren Zimmer für Hinweise, wie ich oben, oder kann ich nur tun:

array2 = array1

InformationsquelleAutor der Frage DillPixel | 2013-03-13

c memory memory-management pointers

63

Reservierten Arrays

Mit einem reservierten Arrays es ist einfach genug, zu Folgen.

Deklarieren Sie das array von Zeigern. Jedes element in diesem array zeigt auf eine struct Test:
```
struct Test *array[50];
```
Dann zuordnen und ordnen Sie die Zeiger auf die Strukturen aber, die Sie wollen. Mit einer Schleife wäre einfach:
```
array[n] = malloc(sizeof(struct Test));
```
Deklarieren Sie einen Zeiger auf dieses array:
```
                               //an explicit pointer to an array 
struct Test *(*p)[] = &array;  //of pointers to structs
```
Dies ermöglicht die Verwendung (*p)[n]->data; Verweis auf die N-te Mitglied.

Mach dir keine sorgen, ob dieses Zeug ist verwirrend. Es ist wahrscheinlich der schwierigste Aspekt der C.

Dynamische Linear-Array -

Wenn Sie nur wollen, reservieren Sie einen block von structs effektiv ein array von structs, nicht Zeigern auf Strukturen), und einen Zeiger auf den block, Sie können es leichter:
```
struct Test *p = malloc(100 * sizeof(struct Test));  //allocates 100 linear
                                                     //structs
```
Können Sie dann auf dieser Zeiger:
```
struct Test **pp = &p
```
Brauchen Sie nicht ein array von Zeigern auf Strukturen, nicht mehr, aber es vereinfacht die ganze Sache erheblich.

Dynamischen Arrays von Dynamisch Zugewiesenen Strukturen

Die flexibelste, aber nicht oft gebraucht. Es ist sehr ähnlich wie das erste Beispiel, erfordert aber eine zusätzliche Zuteilung. Ich habe geschrieben ein Programm, um dies zu zeigen, stellen in Ordnung.
```
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

struct Test {
    int data;
};

int main(int argc, char **argv)
{
    srand(time(NULL));

    //allocate 100 pointers, effectively an array
    struct Test **t_array = malloc(100 * sizeof(struct Test *));

    //allocate 100 structs and have the array point to them
    for (int i = 0; i < 100; i++) {
        t_array[i] = malloc(sizeof(struct Test));
    }

    //lets fill each Test.data with a random number!
    for (int i = 0; i < 100; i++) {
        t_array[i]->data = rand() % 100;
    }

    //now define a pointer to the array
    struct Test ***p = &t_array;
    printf("p points to an array of pointers.\n"
       "The third element of the array points to a structure,\n"
       "and the data member of that structure is: %d\n", (*p)[2]->data);

    return 0;
}
```
Ausgabe:
```
> p points to an array of pointers.
> The third element of the array points to a structure,
> and the data member of that structure is: 49
```
Oder das ganze set:
```
for (int i = 0; i < 100; i++) {
    if (i % 10 == 0)
        printf("\n");
    printf("%3d ", (*p)[i]->data);
}

 35  66  40  24  32  27  39  64  65  26 
 32  30  72  84  85  95  14  25  11  40 
 30  16  47  21  80  57  25  34  47  19 
 56  82  38  96   6  22  76  97  87  93 
 75  19  24  47  55   9  43  69  86   6 
 61  17  23   8  38  55  65  16  90  12 
 87  46  46  25  42   4  48  70  53  35 
 64  29   6  40  76  13   1  71  82  88 
 78  44  57  53   4  47   8  70  63  98 
 34  51  44  33  28  39  37  76   9  91 
```
Dynamisches Zeiger-Array von Single-Dynamische Zugewiesen Structs

Diesem letzten Beispiel ist sehr spezifisch. Es ist ein dynamisches array von Zeigern wie wir gesehen haben in den vorherigen Beispielen, aber im Gegensatz zu denen, die Elemente sind alle vergeben single Zuordnung. Dies hat auch seinen nutzen, besonders für die Sortierung von Daten in verschiedenen Konfigurationen, wobei die original-Zuweisung ungestört.

Wir beginnen mit der Zuteilung von einzelnen block-Elementen wie in den meisten basic-single-block-Allokation:
```
struct Test *arr = malloc(N*sizeof(*arr));
```
Nun teilen wir ein separate block von Zeigern:
```
struct Test **ptrs = malloc(N*sizeof(*ptrs));
```
Wir dann füllen Sie jedes slot-in unserer Zeiger-Liste mit der Adresse eines unserer original-array. Da die Zeiger-Arithmetik ermöglicht, uns zu bewegen von element zu element-Adresse, das ist straight-forward:
```
for (int i=0;i<N;++i)
    ptrs[i] = arr+i;
```
Zu diesem Zeitpunkt die folgenden beziehen sich beide auf das gleiche element Feld
```
arr[1].data = 1;
ptrs[1]->data = 1;
```
Und nach überprüfung der oben genannten, ich hoffe, es ist klar warum.

Wenn wir fertig sind mit dem Zeiger-array und dem original-block-array werden Sie befreit, als:
```
free(ptrs);
free(arr);
```
Hinweis: wir sind NICHT frei jedes Element in der ptrs[] Arrays einzeln. Das ist nicht, wie Sie zugeteilt wurden. Sie wurden zugeteilt als einen einzigen block (verweist arr), und das ist, wie Sie freigegeben werden soll.

Warum würde jemand dies tun wollen? Mehrere Gründe haben.

Erste, radikal reduziert die Anzahl der Speicher-Zuweisung fordert. Dann lieber N+1 (ein Zeiger-array, N für die einzelnen Strukturen) haben Sie jetzt nur zwei: eine für die array-block und eine für die Zeiger-array. Speicherzuordnungen sind eine der teuersten Operationen eines Programms anfordern können, und wo möglich, ist es wünschenswert, um Sie zu minimieren (Hinweis: Datei-IO ist ein weiterer, fyi).

Einem anderen Grund: Mehrere Darstellungen der gleichen Basis-array von Daten. Angenommen, Sie möchten die Daten zu Sortieren, sowohl auf-und absteigenden, und haben beide sortiert Darstellungen zur Verfügung gleichzeitig. Sie duplizieren könnte das Daten-array, das würde aber erfordern eine Menge kopieren und Essen erhebliche Speicher-Nutzung. Stattdessen weisen Sie eine zusätzliche Zeiger-array und füllen Sie es mit Adressen aus dem base-array, dann Sortieren, die pointer-array. Das hat vor allem erhebliche Vorteile, wenn die zu sortierenden Daten ist groß (vielleicht Kilobyte, oder auch mehr, pro Stück) Die original-Objekte bleiben in Ihrer ursprünglichen Position in das base-array, aber jetzt haben Sie einen sehr effizienten Mechanismus, in die Sie Sortieren können, ohne dass Sie tatsächlich bewegen. Sortieren Sie das array von Zeigern auf Elemente; die Elemente nicht verschoben werden, an alle.

Ich weiß, das ist eine Menge zu nehmen, aber Zeiger Nutzung ist entscheidend für das Verständnis der viele mächtige Dinge, die Sie tun können, mit der Sprache C, so trifft die Bücher und fortlaufend aktualisieren Sie Ihr Gedächtnis. Es wird wieder kommen.

InformationsquelleAutor der Antwort teppic
3

Kann es besser sein, zu erklären, eine tatsächliche array, wie andere vorgeschlagen haben, aber Ihre Frage scheint zu sein, mehr über Speicher-management, so werde ich das diskutieren.
```
struct Test **array1;
```
Dies ist ein Zeiger auf die Adresse einer struct Test. (Und nicht einen Zeiger auf die struct selbst; es ist ein Zeiger auf einen Speicherbereich, der hält die Adresse der Struktur ist.) Die Deklaration reserviert Speicher für die Zeiger, aber nicht für die Elemente, die es zu Punkten. Da ein array zugegriffen werden kann per Zeiger Sie können für die Arbeit mit *array1 als ein Zeiger auf ein array, dessen Elemente vom Typ struct Test. Aber es ist noch nicht das eigentliche array für es zu zeigen.
```
array1 = malloc(MAX * sizeof(struct Test *));
```
Dieser reserviert Speicher zu halten MAX Zeiger auf Elemente vom Typ struct Test. Es spielt auch nicht reservieren Sie Speicher für die Strukturen selbst, sondern nur eine Liste von Zeigern. Aber jetzt können Sie Sie behandeln array als ein Zeiger zu einem zugeordneten array von Zeigern.

Um array1 können, benötigen Sie den tatsächlichen Strukturen. Sie können dies tun, indem Sie einfach erklären jeder struct mit
```
struct Test testStruct0;  //Declare a struct.
struct Test testStruct1;
array1[0] = &testStruct0;  //Point to the struct.
array1[1] = &testStruct1;
```
Können Sie auch die Zuordnung der Strukturen auf dem heap:
```
for (int i=0; i<MAX; ++i) {
  array1[i] = malloc(sizeof(struct Test));
}
```
Sobald Sie Speicher zugewiesen ist, können Sie eine neue variable erstellen, die auf die gleiche Liste von structs:
```
struct Test **array2 = array1;
```
Brauchen Sie nicht zu reservieren, zusätzliche Speicher, weil array2 verweist auf den gleichen Speicher haben Sie zugeordnet array1.

Manchmal wollenum über einen Zeiger auf eine Liste von Zeigern, aber es sei denn, Sie tun etwas besonderes, Sie möglicherweise in der Lage zu
```
struct Test *array1 = malloc(MAX * sizeof(struct Test));  //Pointer to MAX structs
```
Diese deklariert die Zeiger array1reserviert genug Speicher für MAX Strukturen und Punkte array1 zu, dass der Speicher. Sie haben nun Zugriff auf die Strukturen wie diese:
```
struct Test testStruct0 = array1[0];     //Copies the 0th struct.
struct Test testStruct0a= *array1;       //Copies the 0th struct, as above.
struct Test *ptrStruct0 = array1;        //Points to the 0th struct.

struct Test testStruct1 = array1[1];     //Copies the 1st struct.
struct Test testStruct1a= *(array1 + 1); //Copies the 1st struct, as above.
struct Test *ptrStruct1 = array1 + 1;    //Points to the 1st struct.
struct Test *ptrStruct1 = &array1[1];    //Points to the 1st struct, as above.
```
Also, was ist der Unterschied? Ein paar Dinge. Klar, die erste Methode erfordert, dass Sie Speicher für den Zeiger und dann zuweisen zusätzlicher Speicher für die Strukturen selbst; die zweite lässt Sie sich mit einem malloc() nennen. Was macht die Mehrarbeit, die Sie kaufen?

Seit der ersten Methode gibt Ihnen eine tatsächliche array von Zeigern auf Test Strukturen, jeder Zeiger kann auf jedes Test struct, irgendwo im Speicher; Sie müssen nicht zusammenhängend sein. Darüber hinaus können Sie reservieren und gratis-Speicher für jeden tatsächlichen Test Struktur wie nötig, und Sie können zuweisen der Zeiger. So, zum Beispiel, können Sie tauschen zwei Strukturen einfach durch den Austausch von Zeigern:
```
struct Test *tmp = array1[2];  //Save the pointer to one struct.
array1[2] = array1[5];         //Aim the pointer at a different struct.
array1[5] = tmp;               //Aim the other pointer at the original struct.
```
Auf der anderen Seite, ist die zweite Methode ordnet einem einzigen zusammenhängenden block von Speicher für alle Test Strukturen und Partitionen in MAX Elemente. Und jedes element in dem array befindet sich an einer festen position; der einzige Weg, tauschen Sie zwei Strukturen ist, Sie zu kopieren.

Zeiger sind eine der nützlichsten Konstrukte in C, aber Sie können auch zu den am schwierigsten zu verstehen. Wenn Sie planen, auch weiterhin mit C, wird es wahrscheinlich eine lohnende Investition, verbringen einige Zeit spielen mit Zeigern, arrays und einen debugger, bis Sie sind komfortabel mit Ihnen.

Glück!

InformationsquelleAutor der Antwort Adam Liss
2

Schlage ich vor, dass bauen Sie diese aus einer Schicht zu einer Zeit typdefs Ebenen erstellen von Typen. Dadurch werden auch die verschiedenen Arten benötigt wird, ist viel klarer.

Zum Beispiel:
```
typedef struct Test {
   int data;
} TestType;

typedef  TestType * PTestType;
```
Diese wird erstellen Sie zwei neue Arten, eine für die Struktur und einen Zeiger auf die struct.

So weiter, wenn Sie möchten, ein array von structs dann würden Sie Folgendes verwenden:
```
TestType array[20];  //creates an array of 20 of the structs
```
Wenn Sie möchten, ein array von Zeigern auf die Strukturen dann würden Sie Folgendes verwenden:
```
PTestType array2[20];  //creates an array of 20 of pointers to the struct
```
Dann, wenn Sie zuweisen möchten structs in dem array, das Sie sowas machen würde wie:
```
PTestType  array2[20];  //creates an array of 20 of pointers to the struct
//allocate memory for the structs and put their addresses into the array of pointers.
for (int i = 0; i < 20; i++) {
    array2 [i] = malloc (sizeof(TestType));
}
```
C nicht zulässt, dass Sie zum zuweisen eines Arrays zu einem anderen. Stattdessen müssen Sie eine Schleife verwenden, ordnen Sie jedem element eines array auf ein element des anderen.

EDIT: ein Weiterer Interessanter Ansatz

Ein anderer Ansatz wäre, mehr Objekt-orientierten Ansatz, in dem Sie die Kapseln ein paar Dinge. Zum Beispiel mit der gleichen Schichten von Typen, die wir erstellen zwei Typen:
```
typedef struct _TestData {
    struct {
        int myData;   //one or more data elements for each element of the pBlob array
    } *pBlob;
    int nStructs;         //count of number of elements in the pBlob array
} TestData;

typedef TestData *PTestData;
```
Als Nächstes haben wir eine helper-Funktion, die wir verwenden, um das Objekt zu erstellen, entsprechend dem Namen genug CreateTestData (int nArrayCount).
```
PTestData  CreateTestData (int nCount)
{
    PTestData ret;

    //allocate the memory for the object. we allocate in a single piece of memory
    //the management area as well as the array itself.  We get the sizeof () the
    //struct that is referenced through the pBlob member of TestData and multiply
    //the size of the struct by the number of array elements we want to have.
    ret = malloc (sizeof(TestData) + sizeof(*(ret->pBlob)) * nCount);
    if (ret) {   //make sure the malloc () worked.
            //the actual array will begin after the end of the TestData struct
        ret->pBlob = (void *)(ret + 1);   //set the beginning of the array
        ret->nStructs = nCount;           //set the number of array elements
    }

    return ret;
}
```
Nun können wir unser neues Objekt in der Quelle code-segment weiter unten. Es sollte überprüft werden, ob die zurückgegebenen Zeiger aus CreateTestData() ist gültig, aber das ist wirklich nur um zu zeigen, was getan werden könnte.
```
PTestData  go = CreateTestData (20);
{
    int i = 0;
    for (i = 0; i < go->nStructs; i++) {
        go->pBlob[i].myData = i;
    }
}
```
In einer dynamischen Umgebung können Sie auch wollen, um eine ReallocTestData(PTestData p) Funktion, würde eine Neuverteilung TestData Objekt, um zu ändern die Größe des Arrays im Objekt enthaltenen.

Mit diesem Ansatz, wenn Sie fertig sind, mit einem bestimmten Testdaten-Objekt, können Sie einfach kostenlos das Objekt in free (go) und das Objekt und das array sind beide befreit zugleich.

Edit: Die Erweiterung Weiter

Mit eingekapselten geben wir nun noch ein paar andere interessante Dinge. Zum Beispiel können wir eine Kopie-Funktion, PTestType CreateCopyTestData (PTestType pSrc) würde eine neue Instanz erstellen, und kopieren Sie dann das argument für ein neues Objekt. Im folgenden Beispiel verwenden wir erneut die Funktion PTestType CreateTestData (int nCount) wird, erstellen Sie eine Instanz der Art, mit der Größe des Objekts, werden wir kopieren. Nach dem erstellen des neuen Objekts, werden wir eine Kopie der Daten vom Quell-Objekt. Der Letzte Schritt ist, zu reparieren, die Zeiger, die in das source-Objekt verweist auf seine Daten-Bereich, so dass Zeiger in das neue Objekt verweist nun auf den Datenbereich, der sich eher als die Daten, die Fläche des alten Objekts.
```
PTestType CreateCopyTestData (PTestType pSrc)
{
    PTestType pReturn = 0;

    if (pSrc) {
        pReturn = CreateTestData (pSrc->nStructs);

        if (pReturn) {
            memcpy (pReturn, pSrc, sizeof(pTestType) + pSrc->nStructs * sizeof(*(pSrc->pBlob)));
            pReturn->pBlob = (void *)(pReturn + 1);   //set the beginning of the array
        }
    }

    return pReturn;
}
```
InformationsquelleAutor der Antwort Richard Chambers
2

Strukturen sind nicht sehr Verschieden von anderen Objekten. Beginnen wir mit den Zeichen:
```
char *p;
p = malloc (CNT * sizeof *p);
```
*p ist ein Charakter, so sizeof *p ist sizeof (char) == 1; wir teilten CNT-Zeichen. Weiter:
```
char **pp;
pp = malloc (CNT * sizeof *pp);
```
*p ist ein Zeiger auf Zeichen, so sizeof *pp ist sizeof (char*). Wir teilten CNT-Zeiger. Weiter:
```
struct something *p;
p = malloc (CNT * sizeof *p);
```
*p ist eine Struktur, etwas, so sizeof *p ist sizeof (struct etwas). Wir teilten CNT-struct-jährigen. Weiter:
```
struct something **pp;
pp = malloc (CNT * sizeof *pp);
```
*pp ist ein Zeiger auf struct, so sizeof *pp ist sizeof (struct something*). Wir teilten CNT-Zeiger.

InformationsquelleAutor der Antwort wildplasser

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.