Dynamic structure with array and array count

I don't know if the title was the best choice but I dunno what else to write there... Here's my problem:

I have the following structures:

Code:

---

struct example1 {
    int size;
    int items[20];
}

struct example2 {
    int size;
    int items[100];
}

---

Both items array on both the structures will have only numbers between 1 and 50 (for instance), if they have 0 it means it is a position in the array that it's not being used. So, if size is like 15 (in the first structure) I only go from positions 0 and 14 in the array and ll the others will only have zeros.

My question is: is, somehow, possible to have only one structure instead of those 2 but defining the items array maximum size dynamically while declaring a variable?

Or with some other approach? I just didn't want to use 2 or more structures for this kind of stuff just cause they are not all of the same size and I didn't want to allocate lots of memory (items[100]) when I only need 20 for some variables, know what I mean?

So, is it possible?

Define your struct like this:

Code:

---

struct exampleA
{
        int size;
        int *items;
};

---

When you create it, for example:

Code:

---

struct exampleA exa;
exa.size = 100;
exa.items = malloc(sizeof(*(exa.items))*exa.size);

---

Replace 100 with whatever you want the size to be (for example replace it with a function parameter).

For all intents and purposes, items will now function as an array. Just remember to specifically free it.

I'll try that, thanks...

However, that do you mean by "Just remember to specifically free it."? I'm asking this cause I've already use malloc and realloc on lots of code and never free any memory and I believe that's not a good choice.

Any guide/tutorial/faq you could point me to to learn more about when (and how) should I free whatever I allocate memory?

Basically, you just free() dynamically allocated memory when you're finished with it.

You also have to be careful to free() memory that you would soon have no references to. So if a function allocates some memory but doesn't return it, free the memory before the function returns; otherwise, the only pointer to the memory will be lost and will not be able to free it at a later point in time.

free() takes a pointer which malloc() or realloc() returned as an argument. It doesn't change the pointer, but after the free() call you can no longer access the pointer.

Code:

---

int *x = malloc(sizeof(*x));

x = 5;
printf("x = %d\n");

free(x); /* Memory can be reclaimed now later on. */

---

If you don't free the memory, and you're allocating a lot of these structs, you may end up with a situation where you run out of memory. You should get into the habbit of free()ing memory that you allocate.

One school of thought is that in some cases, you should not free() memory, but this does not appear to be one of those cases.

Did you mean this?

Code:

---

*x = 5;
printf("x = %d\n", x);

---

Wow, that's bad.... Remind me to proof-read my code about 3 more times before I post. lol...

Alright, I'll give this a try and check my whole code for memory allocation and implement the free() function one by one one every situation and check if the code runs anyway...

I'll post something later on if I still have any issues with this...

Thanks a lot.

What operating system are you using? Valgrind is quite nice for detecting memory leaks if you think you've fixed them all, but it only runs under Linux. There are other leak checkers for Windows and other platforms, but I have no experience with them.

I'm using linux, and valgrind is on portage at the stable tree (gentoo). How do I use it?

better yet

Code:

---

*x = 5;
printf("x = %d\n", *x);

---

I think you may be interested in what is called a "Flexible array member". Basically it is an array declared at the end of structure with no set size:

Code:

---

struct foo
{
  int size;
  char arr[];
}

---

Then when you go to allocate memory for your structure, you allocate the size of the struct plus the number of bytes you want to allocate for the array at the end. I'm not too sure about the details (the most I've seen it used is in winapi), but I believe this functionality is defined in C99, more information: Flexible array members

Isn't that what MacGyver suggested?

Better yet again ;)

Code:

---

int *x = NULL;

if((x = malloc(sizeof(*x)) == NULL)
{
    perror("Malloc failed");
    exit(1);
}

*x = 5;
printf("x = %d\n", *x);

free(x);
x = NULL;

---

Quote:

---

Originally Posted by Nazgulled

Isn't that what MacGyver suggested?

---

No: one way you are allocating memory for the struct, then explicitly allocating memory for the array; in the other way you are allocating memory for both at the same time (as well, there are also other suttle differences).