I have a structure as below:
struct Query {
int pages[];
int currentpage;
};
I was wondering if it was possible to set the size of this array after creating the structure.
Query new = malloc(sizeof(struct Query));
After this, I will perform some calculations which will then tell me the size that pages[] needs to be. If pages[] needed to be of size 4, how can I set it as such?
In C99 you can use Flexible array members:
struct Query {
int currentpage;
int pages[]; /* Must be the last member */
};
struct Query *new = malloc(sizeof(struct Query) + sizeof(int) * 4);
realloc example. BTW flexible arrays must be used by "expert" people, my personal opinion.
reallocing with a different size (than the first malloc) seems dangerous to me, isn't it? For this concrete case, I think OP means allocate the struct without knowing the size of array at runtime (there is only an int and an array in the struct and the int currentPage can be stored in a temporary variable before malloc and then reassigned to the struct), but I could be wrong. Excuse my poor english.realloc can be more dangerous than using malloc. I mean: you have to know what you are doing using Flexible arrays. +1Change the type of pages member to pointer.
struct Query {
int *pages;
int currentpage;
};
struct Query *test = malloc(sizeof(struct Query));
if (test != NULL)
{
//your calculations
test->pages = malloc(result_of_your_calcs);
if (test->pages != NULL)
{
// YOUR STUFF
}
else
{
// ERROR
}
}
else
{
// ERROR
}
When you'll free your struct, you have to do that on the contrary.
free(test->pages);
free(test);
if (test->pages == NULL) { /* ERROR */ }, not error if test->pages != NULLYou can use a Flexible array member (details in @AlterMann's answer) (C99+), or a Zero length array (GNU C).
Quoting from https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html,
Zero-length arrays are allowed in GNU C. They are very useful as the last element of a structure that is really a header for a variable-length object:
struct line { int length; char contents[0]; }; struct line *thisline = (struct line *) malloc (sizeof (struct line) + this_length); thisline->length = this_length;
For standard C90, the linked site mentions
In ISO C90, you would have to give
contentsa length of 1, which means either you waste space or complicate the argument tomalloc.
This means that for the code to work in standard C90/C89, char contents[0]; should be char contents[1];.
struct SIZED_ARRAY {int size; int dat[0];} it would be possible to create an initialized instance via struct { SIZED_ARRAY arr; int dat[4];} my_array = {{4}, {1,2,3,4}};`. While some C99 compilers offer useful extensions, I don't think C99 itself offers any practical equivalent.Declare it as pointer and use malloc afterwards
struct Query {
int * pages;
int currentpage;
};
. . .
struct Query obj;
obj.pages = malloc(n * sizeof(int)); // n is the length you want
The best solution would be to use pointers to int instead of array.
You will need to change :
int pages[];
to :
int *pages;
and then dynamically allocate it like this :
Query *new = malloc(sizeof(struct Query));
if (new == NULL)
printf ("Error\n");
else
{
new->pages = malloc(4*sizeof(int));
if (new->pages == NULL)
printf ("Error\n");
}
Otherwise if you want to keep your format, you will use C99 mode. Declare pages as the last member of your struct, like this :
struct Query {
int currentpage;
int pages[];
};
and then do :
Query *new = malloc(sizeof(struct Query) + 4*sizeof(int));
Query * new = ... ?
new->pages = malloc(4*sizeof(int)); will cause a segmentation fault if the previous malloc for new fails.
int pages[];-->int *pages;and thenmalloc-ate it. Remember that pages have to befreeed before the whole structurefree.pagesbe an int pointer instead. That way you can allocate memory for it in the heap with malloc after you've created the struct.