CODEWITHSUNDEEP
cdata-structuresstruct
KAKAK
KAKAK

Reputation: 899

how do i delete arrays of typedef structs?

I am trying to delete an array of initialized structs e.g. reset the array

My struct:

   struct entry{
        char name[NAME_SIZE];
        int mark;
    };

    typedef struct entry Acct;
    Acct dism2A03[MAX_ENTRY];
    Acct clear[0];        << temp struct to set original struct to null

My attempt:

entry_total keeps track of how many structs in the struct array dism2A03[x] have values set in them.

I tried to create an empty array of the same struct clear[0]. Looped through initialized arrays in dism2A03[x] and set them to clear[0]

       for(m=0;m<entry_total;m++){
            dism2A03[m]=clear[0];           
        }
        break;

However, it is setting them to 0, i want them to become uninitialized e.g. no values in them

Upvotes: 0

Views: 1881

Answers (2)

Nikos C.
Nikos C.

Reputation: 51840

You cannot have memory with no value in it. It's physically impossible. It's due to the laws of physics of our universe :-)

Also, this:

Acct clear[0];

is wrong. You cannot have an array with zero elements. Some compilers will allow this as an extension, but it's not valid C. And for the compilers that allow this, it doesn't do what you think it does.

It would seem to me that what you want instead is to resize the array. To do that, you would need to copy the elements you want to keep into a new array, and then free() the old one. To do that, you need to create dism2A03 using dynamic memory:

Acct *dism2A03 = malloc(sizeof(Acct) * MAX_ENTRY);
if (dism2A03 == NULL) {
    // Error: We're out of memory.
}

(malloc() returns NULL if there's no more free memory, and the code checks that. Usually all you can do if this happens is terminate the program.)

When you want a new array with some elements removed, then you should back up the starting address of the current one:

Acct* oldArray = dism2A03;

then create a new one with the new size you want:

dism2A03 = malloc(sizeof(Acct) * NEW_SIZE);
if (dism2A03 == NULL) {
    // Error: We're out of memory.
}

copy the elements you want from the old array (oldArray) to the new one (dism2A03) - which is up to you, I don't know which ones you want to keep - and after than you must free the old array:

free(oldArray);

As a final note, you might actually not want to create a new array at all. Instead, you could keep having your original, statically allocated array ("statically allocated" means you're not using malloc()):

Acct dism2A03[MAX_ENTRY];

and have a index variable where you keep track of how many useful elements are actually in that array. At first, there are 0:

size_t dism2A03_size = 0;

As you add elements to that array, you do that at the position given by dism2A03_size:

dism2A03[dism2A03_size] = <something>
++dism2A03_size; // Now there's one more in there, so remember that.

While doing so, you need to make sure that dism2A03_size does not grow larger than the maximum capacity of the array, which is MAX_ENTRY in your case. So the above would become:

if (dism2A03_size < MAX_SIZE) {
    dism2A03[dism2A03_size] = <something>
    ++dism2A03_size; // Now there's one more in there, so remember that.
} else {
    // Error: the array is full.
}

As you can see, adding something to the end of the array is rather easy. Removing something from the end of the array is just as easy; you just decrement dism2A03_size by one. However, "removing" something from the middle of the array means copying all following elements by one position to the left:

for (size_t i = elem_to_remove + 1; i < dism2A03_size; ++i) {
    dism2A03[i - 1] = dism2A03[i];
}
--dism2A03_size; // Remember the new size, since we removed one.

Note that you should not attempt to remove an element if the array is empty (meaning when dism2A03_size == 0.)

There's also the case of adding a new elements in the middle of the array rather than at the end. But I hope that now you can figure that out on your own, since it basically a reversed version of the element removal case.

Also note that instead of copying elements manually one by one in a for loop, you can use the memcpy() function instead, which will do the copying faster. But I went with the loop here so that the logic of it all is more obvious (hopefully.)

Upvotes: 1

Giuseppe Pes
Giuseppe Pes

Reputation: 7912

when you declare an array in this way Acct dism2A03[MAX_ENTRY]; the array is allocated in the stack, therefore it will be removed when the function will perform the return statement.

What you can do is to allocate the structure in the heap via malloc/calloc, and then you can free that memory area via the free function.

For example : 

 typedef struct entry Acct;
  Acct * dism2A03 = calloc(MAX_ENTRY, sizeof( struct entry));
 // ....
  free(dism2A03);

Upvotes: 0

Related Questions