Malloc un pointeur sur un pointeur sur un tableau de structure par référence

Question

Le code ci-dessous est compilé, mais se bloque immédiatement pour des raisons évidentes pour les autres, mais pas pour moi. Je n'arrive pas à comprendre, mais quelqu'un peut-il me dire comment résoudre ce problème?

*array_ref[2] = array[0];
*array_ref[3] = array[1];

Il se bloque à chaque fois sur cette partie.

typedef struct test {
    char *name;
    char *last_name;
} person;



int setName(person ** array, person ***array_ref) {

    *array = malloc (5 * sizeof(person));
    *array_ref= malloc(5 * sizeof(person*));

   array[0]->name = strdup("Bob");
   array[1]->name = strdup("Joseph");
   array[0]->last_name = strdup("Robert");
   array[1]->last_name = strdup("Clark");


*array_ref[2] = array[0];
*array_ref[3] = array[1];


    return 1;
}



int main()
{
    person *array;
    person **array_r;

   setName(&array,&array_r);

    printf("First name is %s %s\n", array[0].name, array[0].last_name);
    printf("Second name is %s %s\n", array_r[3]->name, array_r[3]->last_name);

     while(1) {}
    return 0;
}

Answer 1

L'opérateur [] a une priorité supérieure à l'opérateur unaire * * . Par conséquent, ceci:

*array_ref[2] = array[0];
*array_ref[3] = array[1];

signifie en réalité:

*(array_ref[2]) = array[0];
*(array_ref[3]) = array[1];

Les types sont corrects ici, c'est pourquoi il compile. Mais d'après votre code, il est clair que votre intention était réellement:

(*array_ref)[2] = array[0];
(*array_ref)[3] = array[1];

Utilisez donc simplement des parenthèses.

Answer 2

Vous avez alloué de l'espace pour les pointeurs array_ref, mais pas pour ce qu'ils indiquent.

Answer 3

Essayez de modifier les éléments suivants dans setName ()

 *array_ref[2] = array[0];
 *array_ref[3] = array[1];

à

*(*array_ref+2) = array[0];
*(*array_ref+3) = array[1];

Cela fonctionne.

Answer 4

array [1] - > name est votre problème. Cela devrait être (* array) [1] .name . Remarquez comment les deux ne sont pas équivalents. Toutes les utilisations similaires ont le même problème, à l'exception de [0] , qui fait accidentellement la bonne chose.

N'oubliez pas que array , paramètre de fonction n'est pas votre tableau, c'est un pointeur sur votre tableau.

Answer 5

Dans les fonctions comme celle-ci, je préfère un code tel que:

int setName(person ** out_array, person ***out_array_ref) {
    person* array = malloc(5 * sizeof(person));
    person** array_ref = malloc(5 * sizeof(person*));
    array[0].name = strdup("Bob");
    array[1].name = strdup("Joseph");
    array[0].last_name = strdup("Robert");
    array[1].last_name = strdup("Clark");
    // I'm guessing this was your intent for array_ref, here:
    array_ref[2] = &array[0];
    array_ref[3] = &array[1];

    *out_array = out_array;
    *out_array_ref = array_ref;
    return 1;
}

Notez que cela capture à la fois array [1] - > name comme indiqué par Roger Pate, et * array_ref [2] = array [0] comme (presque ) noté par Pavel - dont la solution (* array_ref) [2] = array [0] assigne à partir d'un person non alloué> array [1] - difficiles à remarque avec la déréférence supplémentaire.

Bien sûr, je le fais principalement parce que j'utilise le C ++, ce qui augmente la sécurité des exceptions;).