Thread: I have segmentation fault with double pointers and pseudo generics using realloc

void inselem_array(Item *a, int *n)
...
a = realloc(a, *n * sizeof(Item));

Note that this will not change the value of 'a' as far as the caller of this function is concerned.
They will still be using the old pointer.

Which, if realloc moves the memory somewhere else, will be a big problem.

Code:

Item *inselem_array(Item *a, int *n) {
  int i, pos;
  Item item;
  printf("Insert new element\n");
  item = (inputItem());
  printf("Insert position for new element\n");
  scanf("%d", &pos);
  if (pos <= *n) {
    *n = *n + 1;
    a = realloc(a, *n * sizeof(Item));
 
 
    i = *n - 1;
    while (i > pos) {
      a[i] = a[i - 1];
      i--;
    }
    a[i] = item;
  } else
    printf("Wrong position\n");

  return a;
}

And main does
a = inselem_array(a, &dim);

*shrug*
I just made the change I suggested, and voilà.

Code:

$ ./a.out 
1 - Insert elements in an array
3 - Insert new element
7 - Output array
-1 - Exit
Write your choice
1
Insert element number 1
22
Insert element number 2
33
Insert element number 3
44

Write your choice
3
Insert new element
42
Insert position for new element
1

Write your choice
7
22 42 33 44 
Write your choice
3
Insert new element
99
Insert position for new element
4

Write your choice
7
22 42 33 44 99 
Write your choice
-1

> So how can I point for a new pointer?
That's what the return a; is for at the end of the function (that I put in).

> But can you tell me what is "*" front function? "*inselem_array"
It tells you that the function is returning a pointer.

> for example can I use inselem_array(&a,&dim); for avoid return?
You can, but you have to do something like

Code:

void inselem_array(Item **a, int *n) {
  int i, pos;
  Item item;
  printf("Insert new element\n");
  item = (inputItem());
  printf("Insert position for new element\n");
  scanf("%d", &pos);
  if (pos <= *n) {
    *n = *n + 1;
    *a = realloc(*a, *n * sizeof(Item));
  
  
    i = *n - 1;
    while (i > pos) {
      (*a)[i] = (*a)[i - 1];
      i--;
    }
    (*a)[i] = item;
  } else
    printf("Wrong position\n");
}

Sorry I have another question for my array.c so I ask here for don't open another thread. I added this function to my array.c to shuffle the array elements and it works with static Item *a; static int dim; in my array.c. Because I deleted Item *a from my main.c

Code:

void random_array() {
                                  int i , j;
                                  Item t;
                                  for (i = dim - 1;i > 0; i--)
                                  {
                                      j = rand() % (i + 1);
                                      t = a[i];
                                      a[i] = a[j];
                                      a[j] = t;
                                     //swap(a[i], a[j]);
                                  }
                           }

So I tried with a function swap (a[i], a[j]) from the file utils.c but it doesn't work:

Code:

void swap (Item pa, Item pb) {
    Item t;
    t=pa;
    pa=pb;
    pb=t;

}

It works with these instructions:

Code:

void swap (Item *pa, Item *pb) 
{
    Item t;
    t=*pa;
    *pa=*pb;
    *pb=t;
}

I know that with "typedef void *Item' Item t is like void *t and Item *a is like void **a, right?

So with double pointers I have a dynamic array with many pointers thanks to a=malloc(numberelements*(sizeof(Item)); and with a[i]=malloc(sizeof(Item) every pointer points to a memory location with many bytes?

Here a image.

So for t I don't need malloc because with t = a[i] t points to memory location pointed from a[i], right?
If yes, why do I have to use in my swap function t = *pa etc. instead of t = pa ? Thanks in advance!

If yes, why do I have to use in my swap function t = *pa etc.

Because you don't just want to swap local copies of the Item objects, you want to swap the Item objects in the caller. Therefore the caller must pass pointers to Item.

Yes, and indeed you can dereference pointers to pointers to void, but you cannot validly dereference pointers to void.