Question

i have a struct “cell” defined as

typedef struct{
int id;
terrainType terrain;
} cell;

i then make a 2d array of cells with

cell** makeCellGrid(int sizeX, int sizeY)
{  
    cell** theArray;  
    int i;

    theArray = (cell**) malloc(sizeX*sizeof(cell*));  

    for ( i = 0; i < sizeX; i++)
    {
        theArray[i] = (cell*) malloc(sizeY*sizeof(cell));  
    }

   return theArray;  
}  

at first i thought this was working fine but a few seg faults later i discovered that with some values (e.g. makeCellGrid(32, 87) ) it breaks.
im fairly fresh with C pointers and memory junk and was hoping some one could point me in the right direction here.

with lower number bounds i had no issue accessing it with

map[i][j].id = x;

and so on

EDIT: forgot to add, from testing, the seg fault originate from

theArray[i] = (cell*) malloc(sizeY*sizeof(cell)); 

Answer 1

The code lacks error checking for the malloc() system call.

So if the first call to malloc() failed the second one (in the loop) tries to assign memory to NULL which indeed leads to the segmentation violation your are witnessing.

You might consider modifing you code like so:

#include <stdlib.h>

typedef struct {
  int id;
  TerrainType terrain;
} CellType;

void freeCellGrid(CellType ** ppCells, size_t sizeX)
{
  size_t i = 0;
  for (; i < sizeX; ++i)
  {
    free(ppCells[i]);
  }

  free(ppCells);
}

CellType ** makeCellGrid(size_t sizeX, size_t sizeY)
{  
    CellType ** ppCells = malloc(sizeX * sizeof(*ppCells));  

    if (ppCells)
    {
      size_t i = 0;

      for (; i < sizeX; ++i)
      {
          ppCells[i] = malloc(sizeY * sizeof(**ppCells));  
          if (NULL == ppCells[i])
          {
            freeCellGrid(ppCells, i);
            ppCells = NULL;

            break;
          }
      }
   }

   return ppCells;  
} 

Notes on my modifications:

• Always check system calls for errors (in the case of malloc() on error NULL is returned)
• Better use an unsigned type to access memory/array indicies; size_t is meant for this
• In C there is no need to cast the value returned by a void * function like malloc()
• Always try to initialise variables as soon as possible; un-initilaised variables very easily lead to “irrational” behaviour of the application
• If working with pointers, it might be helpfull to ‘code’ the level of indirection into their names (I did this here by using the prefix pp to indicated that it’s a 2-level indirection)
• types are different from variables: One way to distinguish this is by starting type names using capitals (CellType) and variables using small letters (ppCells).
• If allocating memory to a pointer and it matters that the size of the allocated memory some suits the pointer’s type it’s always more secure to use the (dereferenced) pointer itself as argument to the sizeof operator then some type. As the declaration of the pointer the memory is allocated to might be changed during develpment and the adjustment of the argument to malloc() will be forgotten. To cut it short: doing as I did is less error prone.
• If encapsulating the dynamical creation of structures (including arrays) it is a could idea to also implement a method which de-allocates it (here: freeCellGrid()). Even better start of with coding this deallocator first, as then you have it by hand when coding the allocator’s error handling (as shown for the second call to malloc()).