C指向带有指针元素的结构的指针-如何分配内存并用作函数输出

Question

If I have the following C struct:

struct group_of_pointers {
    double *p1, *p2, *p3;
} *pointers;

Now, I want to allocate n spaces (each with sizeof double) to pointers->p1, pointers->p2, pointers->p3. How do I do this? Do I have to allocate any space to the pointer to the structure 'pointers' itself?

Thanks.

ETA: Related question: The reason I need this struct is because I want to return 3 variable length arrays from a function. Should I just do

void foo(const double* const input, double *output1, double *output2, double *output3) 

or should I do

struct group_of_pointers *foo(const double* const input)

The former looks a bit confusing with input and output all bundled together. But is it just the way C is?

Answer 1

Yes, you have to allocate space for the structure of pointers first. Then you allocate for each component.

pointers = malloc(sizeof *pointers);
pointers->p1 = malloc(n * sizeof(double));
pointers->p2 = malloc(n * sizeof(double));
pointers->p3 = malloc(n * sizeof(double));

Answer 2

Yes, since your pointers variable is itself a pointer, you need to give it some memory to point to.

struct group_of_pointers {
    double *p1, *p2, *p3;
} *pointers;

pointers = malloc(sizeof(*pointers));

pointers->p1 = malloc(n*sizeof(*pointers->p1));
pointers->p2 = malloc(m*sizeof(*pointers->p2));
pointers->p3 = malloc(o*sizeof(*pointers->p3));

Answer 3

If I'm reading your question correctly, yes, you need the 'pointers' struct to have space, either allocated or on the stack, and you malloc()-or-variant-thereof the space for p1 - p3:

struct group_of_pointers *pointer = malloc(sizeof(*pointer));

pointer->p1 = malloc(n * sizeof(double));
pointer->p2 = malloc(n * sizeof(double));
pointer->p3 = malloc(n * sizeof(double));

/* do stuff here... */

free(pointer->p1);
free(pointer->p2);
free(pointer->p3);
free(pointer);

Of course, I never checked for malloc failure in there, so this code is not to be considered production-ready!

Answer 4

What are you trying to do? Do need a struct that can point to three double values? Then yes, you need to allocate memory for any of those objects:

#include <stdio.h>
#include <stdlib.h>

struct group_of_pointers {
    double *p1, *p2, *p3;
} *pointers;

int main(int argc, char *argv[]) {

   pointers = malloc(sizeof(struct group_of_pointers));
   pointers->p1 =  malloc(sizeof(double));
   pointers->p2 =  malloc(sizeof(double));
   pointers->p3 =  malloc(sizeof(double));

   *(pointers->p1) = 10.0;
   *(pointers->p2) = 20.0;
   *(pointers->p3) = 30.0;

   printf("%lf %lf %lf\n", *(pointers->p1), *(pointers->p2), *(pointers->p3));

   return EXIT_SUCCESS;
}

Answer 5

if those three arrays are highly related, and you use them often as a group you should use the second approach, but instead of creating a structure on the heap you should create it on the stack then pass its pointer to your function, like

void foo(struct group_of_pointers *ptr, const double *input);