c pointeur vers un tableau de structures

Je sais que cette question a été posée à beaucoup de choses, mais je suis encore difficile de savoir comment accéder à leurs structures.

Je veux faire mondial pointeur vers un tableau de structures:

typdef struct test
{
    int obj1;
    int obj2;
} test_t;

extern test_t array_t1[1024];
extern test_t array_t2[1024];
extern test_t array_t3[1025];

extern test_t *test_array_ptr;

int main(void)
{
    test_array_ptr = array_t1;

    test_t new_struct = {0, 0};
    (*test_array_ptr)[0] = new_struct;
}

Mais il me donne des avertissements. Comment dois-je accès aux structures avec []?

De même, comment dois-je créer un tableau de pointeurs de type struct? test_t *_array_ptr[2];?

source d'informationauteur user1539348

  1. 15

    La syntaxe que vous cherchez est un peu lourd, mais il ressemble à ceci:

    //Declare test_array_ptr as pointer to array of test_t
test_t (*test_array_ptr)[];

    Vous pouvez alors l'utiliser comme ceci:

    test_array_ptr = &array_t1;
(*test_array_ptr)[0] = new_struct;

    À rendre la syntaxe plus facile à comprendre, vous pouvez utiliser un typedef:

    //Declare test_array as typedef of "array of test_t"
typedef test_t test_array[];
...
//Declare test_array_ptr as pointer to test_array
test_array *test_array_ptr = &array_t1;
(*test_array_ptr)[0] = new_struct;

    La cdecl utilitaire est utile pour déchiffrer complexe déclarations en C, en particulier lorsque les tableaux et les pointeurs de fonction s'impliquer.

  2. 4

    test_t * test_array_ptr est un pointeur vers test_t. Il pourrait être un pointeur vers l'instance unique de test_tmais il pourrait être un pointeur vers le premier élément d'un tableau d'instances de test_t:

    test_t array1[1024];

test_t *myArray;
myArray= &array1[0];

    ce fait myArray point pour le premier élément de array1 et l'arithmétique des pointeurs permet de traiter ce pointeur comme un tableau. Maintenant, vous pouvez accéder à la 2e élément de array1 comme ceci: myArray[1]qui est égale à *(myArray + 1).

    Mais ce que je comprends, ce que vous voulez vraiment faire, c'est de déclarer un pointeur de pointeur de test_t qui va représenter un tableau de pointeurs vers des tableaux:

    test_t array1[1024];
test_t array2[1024];
test_t array3[1025];

test_t **arrayPtr;
arrayPtr = malloc(3 * sizeof(test_t*));   //array of 3 pointers
arrayPtr[0] = &array1[0];
arrayPtr[1] = &array2[0];
arrayPtr[2] = &array3[0];
  3. 0

    Le problème que vous avez est que vous prenez (*test_array_pointer) qui est le premier élément du tableau. Si vous souhaitez attribuer à un élément du tableau, vous devez faire ce qui suit...

    function foo()
{
    test_array_ptr = array_t1;

    test_t new_struct = {0,0};
    memcpy( &test_array_ptr[0], &new_struct, sizeof( struct test_t ) );
}

    si vous voulez toujours attribuer au premier élément du tableau, vous pourriez faire ceci...

    function foo()
{
    test_array_ptr = array_t1;

    test_t new_struct = {0,0};
    memcpy( test_array_ptr, &new_struct, sizeof( struct test_t ) );
}

    et cela a été souligné à moi par les autres, et quelque chose honnêtement, j'avais complètement oublié pour ne pas l'avoir utilisé dans la meilleure partie de forever, vous pouvez faire l'affectation directe de structures simples dans C...

    function foo()
{
    test_array_ptr = array_t1;

    test_t new_struct = {0,0};
    test_array_ptr[0] = new_struct;
}
  4. 0

    Je voudrais utiliser un pointeur vers un pointeur comme:

    test_t array_t1[1024];
test_t **ptr;
ptr = array_t1;
ptr[0] = ...;
ptr[1] = ...;
etc.