Array of structs - deleting/adding elements and pr

Question

For the below code

struct orderSlip
{
    char source[64];
    char destination[64];
    char item[64];  
    int position;
};
//global
struct orderSlip data[100];

Is there another way of printing out the data for each element other than these methods below:

printf("%s\n",data[0].source);
    printf("%s\n",data[0].destination);
    printf("%s\n",data[0].item);
    printf("%i\n\n", data[0].position);

    printf("%s\n",data[1].source);
    printf("%s\n",data[1].destination);
    printf("%s\n",data[1].item);
    printf("%i\n", data[1].position);

etc

for(int n = 0; n< 3; n++)
{
    printf("%s\n",data[n].source);
    printf("%s\n",data[n].destination);
    printf("%s\n",data[n].item);
    printf("%i\n\n", data[n].position);
}

For deleting and adding, do I have to make a dynamic array of structs? If so, what would be the simplest syntax to do that? Something like this c++ code

int * bobby;
bobby = new int [5];
delete bobby[5];

but in C? I'm guessing it has do with malloc and free

Answer 1

"For deleting and adding, do I have to make a dynamic array of structs? If so, what would be the simplest syntax to do that? Something like this c++ code"

Not if you know that you will never have more than x amount of items or at least check to make sure you aren't exceeding what you planned was the max. Then you can use your static array.

Adding only requires you to have a variable that keeps track of how many items are in the array:

void add_item(struct orderSlip *p,struct orderSlip a,int * num_items)
{
   if ( *num_items < MAX_ITEMS )
   {
      p[*num_items] = a;
      *num_items += 1;
   }
}

Deleting from a static array would require a for loop that would move the items above it down one and decrementing the int keeping track of the number of items.

void delete_item(struct orderSlip *p,int *num_items, int item)
{
   if (*num_items > 0 && item < *num_items && item > -1)
   {
      int last_index = *num_items - 1;
      for (int i = item; i < last_index;i++)
      {
         p[i] = p[i + 1];
      }
      *num_items -= 1;
   }
}

You could simplify printing the struct by passing it to a function that does the work.

void print(const struct orderSlip  *p);

or

void print(const struct orderslip s);

optionally

void print(const struct orderslip s, FILE *fp);

or

void print(const struct orderslip *p, FILE *fp)
{
   fprintf(fp,"%s\n",p->source);
    ...
}

and

void print_all(const struct orderSlip *p, int num_items)



//global
struct orderSlip data[MAX_ITEMS];
int num_items = 0;



int main(void)
{
...
       print_all(data,num_items);                                       
       strcpy(a.source,"source 2");
       strcpy(a.destination,"destination 20");
       strcpy(a.item,"item xyz");
       a.position = 99;
       add_item(data,a,&num_items);
       print_all(data,num_items);
       delete_item(data,&num_items,0);
       print_all(data,num_items);

Answer 2

One way is to allocate each element in your array and just keep an array of pointers

struct orderSlip **data;

data = calloc(100, sizeof(struct orderSlip*)); // 100 pointers to struct

(calloc will make sure memory is zero:ed from the start)

everytime you add a new struct:

data[i] = calloc(1, sizeof(struct orderSlip));

and when you don't need any longer

free(data[i]);

You can also change the size of data by using realloc, see

If you don't need to access the array using index, you could instead consider another type of data structure like a linked list to be truly dynamic.