指向结构数组中的第一个结构？

Question

I have a function that is supposed to be creating structures and storing them in an array of structures.

Lets say this is my structure:

struct str {
    ...
};

The function takes a parameter that looks like this:

struct str **ptr

Which is a pointer to a pointer that points to a structure if I get it right and I am supposed to set this parameter to be pointing to the first element of the array of structures which will be the first structure in that array.

So, if the parameter looks like this, that means that instead of having just an array of structures, I have an array of pointers that point to that structure, right?

Now I have declared the array of pointers to structures like this:

 struct str *structures[20];

because I am expecting to have 20 (pointers to )structures store there.

Then I have a loop that is allocating memory for the structures and is storing them in the array like this:

 struct str *structure;

 structure = malloc(sizeof(struct str));

Then I fill in the parameters of the structure I want like this:

structure->a = 1; structure->b = 2; .........

And I store it in the array like this:

structures[n] = structure;

And I make sure it is stored in the array at the position where I wanted it to be by printing a parameter from the structure each loop like this:

printf("%d\n", structures[7]->a);

My question is, how do I set the parameter of the function to be pointing to the first pointer to a structure in that array?

And did I get it right?

Also, the parameter needs to be taken from main.

And I need to work with these (pointers to)structures of the array outside this one function as well.

What will the parameter look like?

struct str *pointer; ?

Also, wouldn't it be possible to just point the pointer to the array itself and it should automatically be pointing to the first element in it?

So that I could then reference the nth member of the array via the pointer since I need to work with all of them later on?

I have looked at this thread, but I'm still a bit confused so I'd appreciate any feedback.

Answer 1

Reading through this, I notice a few inconsistencies in your post:

Why create an array of pointers to your struct as opposed to a simple array of structs? That is, let's say you have this declaration for your struct:

struct myStruct {
    int x;
    int y;
};

If you want to create an array of those structs just do:

//dynamic
struct myStruct* myArray = malloc(20*sizeof(struct myStruct));
//static
struct myStruct* myArray[20];

Note that both of these return a pointer to the first element of the array (which is of type struct myStruct ). Your array is an array of struct myStruct elements, not an array of struct myStruct* .

An array of struct myStruct elements with size 20 is, for practical purposes, nothing more than contiguous memory big enough to hold 20 struct myStruct elements and represented by the pointer to the first element. Since the memory is contiguous, you can access the 'nth' element of your array by myArray[0] or *(myArray+n) (the latter is possible because an "array" is nothing more than a pointer to the first element of contiguous memory... so "adding" 1 to a pointer of a given type gives you the memory address of the next element... which you deference using the * operator to get the element itself).

It'll be much easier (not to mention much faster) to allocate memory for your array of structs once rather than creating an array of pointers to your structs. And then modify them in place.

So a function that takes in the array and increments that 5th and 6th elements might look like:

void modifyStructs (struct myStruct* myArray)
{
    //modify the fifth struct:
    ++myArray[4].x;
    //modify the sixth struct:
    ++myArray[5].x;
}

The few times you'll want an array of pointers are when:

1. Creating a multidimensional array. Even then, this is really bad for cache performance... it's better to create a 1D array and define a macro for how to access the elements. BLAS/LAPACK do this.
2. Creating an array where some elements should be NULL and you're not using structs. If you're using structs, it's much better to just define a field to identify whether your struct has been populated yet and use a simple array of structs.
3. Creating an array to access a huge number of items but you don't want to allocate all that memory yet. Here, you don't really have a choice.