C：指向函数内结构内部的结构数组的指针

Question

I am pretty new to C. I created a struct and an array of structs to store data and passed each of them to my functions:

int dosomething(struct s1 *struct1, struct s2 *struct2);

struct S1 {
    int a;
    int b;
    int c;
};

struct S2 {
    double x;
    double y;
    double z;
};


int main()
{
    int n = 200;
    struct S1 s1;
    struct S2 *s2 = malloc(n * sizeof(struct S2));

    dosomething(&s1, &s2[0])

    return 0;
}

int dosomething(struct S1 *s1, struct S2 *s2)
{
    s1->a = 1;
    s1->b = 2;
    s1->c = 3;

    s2[0].x = 1.1;
    s2[1].x = 1.123233;
    ...

    return 1;
}

This got pretty annoying over time, so I decided to put them together. Now I am doing this

struct S1 {
    int a;
    int b;
    int c;
    struct S2 *s2;
};

struct S2 {
    double x;
    double y;
    double z;
};


int main()
{
    int n = 200;
    struct S1 s1;
    struct S2 *s2 = malloc(n * sizeof(struct S2));
    s1.s2 = s2;

    dosomething(&s1)

    return 0;
}


int dosomething(struct S1 *s1)
{
    s1->a = 1;
    s1->b = 2;
    s1->c = 3;

    s1->s2[0].x = 1.1;
    s1->s2[1].x = 1.123233;
    ...

    // OR

    struct S2 *s2 = s1->s2;
    s2[0].x = 1.1;
    s2[1].x = 1.123233;
    ...
}

Now, the thing is: I read a lot about pointers to structs, to arrays, to arrays of structs and so on, but I am still not sure, if what I am doing here is correct. C: pointer to array of pointers to structures (allocation/deallocation issues) , c pointer to array of structs , How to declare pointer to array of structs in C , Pointer to array of struct in function . My project is growing to a size where I just don't want to make it worse by trying to make it better.

Do I need to make an array of pointers to the s2.s1[x]?

Do I need to tell the one pointer (struct S2 *s2 = s1->s2) how much elements s2 has?

Are there any pitfalls or could something go wrong?

Answer 1

There is nothing wrong with it, it is a matter of whether or not it fits your requirements and that it is a good design choice in the long term.

Also, you can probably do

s1.s2 = malloc(sizeof *s1.s2);
if (s1.s2 == NULL)
    error_handler(); // do not use s1.s2 after this
dosomething(&s1);

Answer 2

Placing a struct, pointer or an array inside another struct is called composition . You should be placing the S2 array inside the S1 struct if it belongs there .

For example, a Point is a pair of (x, y) coordinates, so it's obvious it should be composed of two int s, ie:

void do_stuff(struct Point pt);

Is better than:

void do_stuff(int x, int y);

But never do this just because you want to spare some typing. Do it if S2 fits inside S1 . If "there is no S1 without S2 " in your program, then it makes sense.

So if these two structs don't belong together, but you find yourself passing the same sequence of parameters to multiple functions, then you can use a variant of OOP refactoring technique called "introduce parameter object" . Ie instead of doing this:

do_stuff(&s1, &s2, &s3);

You can create a new struct whose no other purpose is but to be composed of these parameters:

struct StuffParameters {
    struct S1 * s1;
    struct S2 * s2;
    struct S3 * s3;
};

And then you can pass it to multiple "similar" functions:

struct StuffParameters parameters = { &s1, &s2, &s3 };

do_stuff(&parameters);
do_some_other_stuff(&parameters);
yet_another_function(&parameters);