C: pointeur vers un tableau de pointeurs vers des structures (problèmes d'allocation/deallocation)

Il peut être préférable de déclarer un tableau réel, comme d'autres l'ont suggéré, mais votre question semble être plus sur la gestion de la mémoire, donc je vais en discuter.

struct Test **array1;

Ceci est un pointeur vers l'adresse d'un struct Test. (Pas un pointeur vers la structure elle-même; c'est un pointeur sur un emplacement mémoire qui contient la adresse de la structure.) La déclaration alloue de la mémoire pour le pointeur, mais pas pour les éléments vers lesquels il pointe. Comme un tableau est accessible via des pointeurs, vous pouvez travailler avec *array1 comme un pointeur vers un tableau dont les éléments sont de type struct Test. Mais il n'y a pas encore de tableau réel vers lequel pointer.

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

Cela alloue de la mémoire pour contenir des pointeurs MAX vers des éléments de type struct Test. Encore une fois, il n'alloue pas de mémoire pour les structures elles-mêmes; seulement pour une liste de pointeurs. Mais maintenant, vous pouvez traiter array comme un pointeur vers un alloués tableau de pointeurs.

Pour utiliser array1, Vous devez créer les structures réelles. Vous pouvez le faire par il suffit de déclarer chaque structure avec

struct Test testStruct0;  // Declare a struct.
struct Test testStruct1;
array1[0] = &testStruct0;  // Point to the struct.
array1[1] = &testStruct1;

Vous pouvez également allouer les structures sur le tas:

for (int i=0; i<MAX; ++i) {
  array1[i] = malloc(sizeof(struct Test));
}

Une fois que vous avez alloué de la mémoire, vous pouvez créer une nouvelle variable qui pointe vers la même Liste de structures:

struct Test **array2 = array1;

Vous n'avez pas besoin d'allouer de mémoire supplémentaire, car array2 pointe vers la même mémoire que vous avez allouée à array1.

Parfois, vous voulez avoir un pointeur vers une liste de pointeurs, mais à moins que vous ne fassiez quelque chose de fantaisie, vous peut être capable d'utiliser

struct Test *array1 = malloc(MAX * sizeof(struct Test));  // Pointer to MAX structs

Cela déclare le pointeur array1, alloué suffisamment de mémoire pour les structures MAX, et pointe array1 vers cette mémoire. Maintenant, vous pouvez accéder aux structures comme ceci:

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.

Alors, quelle est la différence? Un certain nombre de choses. De toute évidence, la première méthode vous oblige à allouer de la mémoire pour les pointeurs, puis à allouer de l'espace supplémentaire pour les structures elles-mêmes; la seconde vous permet de vous en sortir avec un appel malloc(). Qu'est-ce que le travail supplémentaire achète vous?

Puisque la première méthode vous donne un tableau réel de pointeurs vers Test structs, chaque pointeur peut pointer vers n'importe quelle Test struct, n'importe où dans la mémoire; ils n'ont pas besoin d'être contigus. De plus, vous pouvez allouer et libérer la mémoire pour chaque structure Test réelle si nécessaire, et vous pouvez réaffecter les pointeurs. Ainsi, par exemple, vous pouvez échanger deux structures en échangeant simplement leurs pointeurs:

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.

D'autre part, la seconde méthode alloue un seul bloc contigu de mémoire pour toutes les structures Test et les partitions en éléments MAX. Et chaque élément du tableau réside à une position fixe; la seule façon d'échanger deux structures est de les copier.

Les pointeurs sont l'une des constructions les plus utiles en C, mais ils peuvent aussi être parmi les plus difficiles à comprendre. Si vous prévoyez de continuer à utiliser C, ce sera probablement un investissement intéressant de passer du temps à jouer avec des pointeurs, des tableaux et un débogueur jusqu'à ce que vous soyez à l'aise avec ils.

Bonne chance!

Je suggère que vous construisiez ceci une couche à la fois en utilisant typdefs pour créer des couches de types. Ce faisant, les différents types nécessaires seront beaucoup plus claires.

Par exemple:

typedef struct Test {
   int data;
} TestType;

typedef  TestType * PTestType;

Cela créera deux nouveaux types, un pour la structure et un pour un pointeur vers la structure.

Donc, si vous voulez un tableau des structures, vous utiliserez:

TestType array[20];  // creates an array of 20 of the structs

Si vous voulez un tableau de pointeurs vers les structures, vous utiliserez:

PTestType array2[20];  // creates an array of 20 of pointers to the struct

Alors si vous souhaitez allouer des structures dans le tableau que vous feriez quelque chose comme:

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 ne vous permet pas d'attribuer un tableau à un autre. Vous devez plutôt utiliser une boucle à attribuer à chaque élément d'un tableau à un élément de l'autre.

EDIT: une Autre Approche Intéressante

Une autre approche serait une approche plus orientée objet dans laquelle vous encapsulez quelques choses. Par exemple, en utilisant les mêmes couches de types, nous créons deux types:

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;

Suivant nous avoir une fonction d'aide que nous utilisons pour créer l'objet, nommée de manière appropriée 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;
}

Maintenant, nous pouvons utiliser notre nouvel objet comme dans le segment de code source ci-dessous. Il devrait vérifier que le pointeur retourné par CreateTestData () est valide mais c'est vraiment juste pour montrer ce qui pourrait être fait.

PTestData  go = CreateTestData (20);
{
    int i = 0;
    for (i = 0; i < go->nStructs; i++) {
        go->pBlob[i].myData = i;
    }
}

Dans un environnement vraiment dynamique, vous pouvez également avoir une fonction ReallocTestData(PTestData p) qui réallouerait un objet TestData afin de modifier la taille du tableau contenu dans le objet.

Avec cette approche, lorsque vous avez terminé avec un objet Testdata particulier, vous pouvez simplement libérer l'objet comme dans free (go) et l'objet et son tableau sont tous deux libérés en même temps.

Modifier: Étendre Plus Loin

Avec ce type encapsulé, nous pouvons maintenant faire quelques autres choses intéressantes. Par exemple, nous pouvons avoir une fonction de copie, PTestType CreateCopyTestData (PTestType pSrc) qui créerait une nouvelle instance, puis copierait l'argument dans un nouvel objet. Dans l'exemple suivant, nous réutilisons la fonction {[13] } qui va créer une instance de notre type, en utilisant la taille de l'objet que nous copions. Après avoir fait la création du nouvel objet, nous faisons une copie des données de l'objet source. La dernière étape consiste à fixer le pointeur qui dans l'objet source pointe vers sa zone de données de sorte que le pointeur dans le nouvel objet pointe maintenant vers la zone de données de lui-même plutôt que la zone de données de l'ancien objet.

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;
}

Les structures ne sont pas très différentes des autres objets. Commençons par les caractères:

char *p;
p = malloc (CNT * sizeof *p);

* p est un caractère, donc sizeof *p est sizeof (char) = = 1; nous avons alloué des caractères CNT. Suivant:

char **pp;
pp = malloc (CNT * sizeof *pp);

*p est un pointeur de caractère, donc sizeof *pp est sizeof (char*). Nous avons alloué des pointeurs CNT. Suivant:

struct something *p;
p = malloc (CNT * sizeof *p);

*p est un struct quelque chose, donc sizeof *p est sizeof (struct quelque chose). Nous avons alloué quelque chose de CNT struct. Suivant:

struct something **pp;
pp = malloc (CNT * sizeof *pp);

* pp est un pointeur sur struct, donc sizeof *pp est sizeof (struct quelque*). Nous avons alloué des pointeurs CNT.