Question

I am trying to have dynamically allocate arrays of structures and perform operations on them but i keep running into segmentation faults. could someone help me out?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void *malloc(size_t size);

typedef struct {
  double x;
  double y;
} coords;

struct figure {
  char fig_name[128];
  int coordcount, size_tracker;
  coords *pointer;
} fig;

void init_fig(int n, struct figure **point)
{
  printf("%u\n", sizeof(coords));
  point[n]->pointer = malloc(sizeof(coords) * 20);  <-------SEGFAULT
  if (point[n]->pointer == NULL){
    exit(-1);
  }
  point[n]->pointer[19].x = 2;
  point[n]->pointer[0].x = 1;
  point[n]->pointer[0].y = 2;
  point[n]->pointer[7].x = 100;
}

int main()
{
  int numfigs = 1;
  struct figure * point;
  point = malloc(sizeof(struct figure) * 16);
  point = &fig;
  point[1].coordcount = 1;
  init_fig(numfigs, &point);
  return 0;
}

I labelled where the first seg fault occurs, (used ddd). what i dont get is that i can manipulate point[1] in main but not in any other function.

Answer 1

I agree with @Maxim Skurydin.
Nevertheless I’d like to explain your mistake in some more details.

Reading your init_fig one assumes that the parameter you pass struct figure **point – is actually array of pointers to struct figure. And this function accesses its n‘th element.

However in your main you do something else. You allocate an array of struct figure, and your point variable points to its head. Then you take the address of this local variable and call your init_fig.

Here’s the problem. init_fig assumes that you pass it an array of pointers, whereas actually this “array” consists of a single element only: the local point variable declared in main.

EDIT:

How to do this properly.

1. Leave main intact, fix init_fig.

This means that actually there’s an array of figure structs. Means – a single memory block, interpreted as an array of consequent structs.

void init_fig(int n, struct figure *point)
{
  printf("%u\n", sizeof(coords));
  point[n].pointer = malloc(sizeof(coords) * 20);  <-------SEGFAULT
  if (point[n].pointer == NULL){
    exit(-1);
  }
  point[n].pointer[19].x = 2;
  point[n].pointer[0].x = 1;
  point[n].pointer[0].y = 2;
  point[n].pointer[7].x = 100;
}

1. Leave init_fig intact. Fix main.

This means that we actually should allocate an array of pointers, every such a pointer should point to an allocated point structure.

int main()
{
  int numfigs = 1;
  struct figure ** point;
  point = malloc(sizeof(struct figure*) * 16);

  for (i = 0; i < 16; i++)
    point[i] = malloc(sizeof(struct figure));

  point[1].coordcount = 1;
  init_fig(numfigs, &point);
  return 0;
}