Help allocating and reallocating memory

Hello there, long time visitor first time poster. :D

I have a problem with the following code... it segfaults as soon as my setFT function is called. I must not be allocating the memory correctly, but what's strange is my temp self-testing code (that **(ptrtwo+5000) = 88 part) actually prints out 88 when I ask it what that particular element is. How is that possible if I haven't allocated that much memory for it?

My goal is to create a pointer to a pointer to an array of longs. Initially, the array[0] element should be this "magic number" we have. That's fine. array[1] should be the size of our "flexible table" which is initialized at 0 until the user uses setFT to add elements.

The ultimate goal is have this dynamic array of elements that allocates, deallocated, and reallocates necessary memory. I just get seg faults :(

I guess my main question(s) is why am I seg faulting, and if I'm seg faulting, how come I can still put long's into my array?! Any suggestions or thoughts would be greatly appreciated. I'm not sure how clear I have been, but if you need clarification on exactly what the heck I'm talking about, I'll try to do just that. Thank you very much!

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include "FlexTab.h"

FlexTab newFT(){

        long **ptrone;
        long *ptrtwo;

        ptrone = malloc(sizeof(long));
        *ptrone = malloc(sizeof(long));

        **ptrone = (long)calloc(2, sizeof(long));
        ptrtwo = malloc(sizeof(long *));

        **(ptrone) = FT_MAGIC;

        ptrtwo = *ptrone;


       
        *(ptrtwo+1) = 0;
       
        *(ptrtwo+5000) = 88; //just a tester
       
        printf("*(ptrtwo+1) is %ld\n", *(ptrtwo+1));
        printf("**ptrone is %ld\n",**ptrone);
        printf("*ptrtwo is %ld\n",*ptrtwo);

        printf("Ptrtwo @ element 5000 is %ld\n", *(ptrtwo+5000)); //it works?!

        return ptrone;

        }

int disposeFT( FlexTab ft ){

                free(*ft);
                free(ft);
                ft = NULL;
                return 0;
       
}

int setFT( FlexTab ft, const int index, const long item ){

        if (index > (**(ft+1)) ){
                **ft = (long)realloc(*ft, (2 * sizeof(long)) + (index * sizeof(long)) );
                **(ft+1) = index;
                **(ft+index+2)=item;
                }
        else if (index < (**(ft+1)) ){
                **(ft+index+2)=item;
                }
                return **(ft+1);
}

int getFT( FlexTab ft, const int index, long *const itemp ){

        if (**ft == FT_MAGIC && *ft != NULL && ft != NULL){
        *itemp = **(ft + index + 2);
        return ( (sizeof(ft)) / (sizeof(long)) );
        }
       
        else if (index >= FT_MAX){
                return -2;
        }
        return 88;
}

---

ptrone is a 2 dimensional array of pointers to longs. The first dimension indicates the number of pointers to longs that you want -- for example is you want an array of 10 pointers then you could write it like this

Code:

---

long *ptrone[10];

---

The same thing using malloc() to allocate the 10 pointers looks like this

Code:

---

long **ptrone;
ptrone = malloc( 10 * sizeof(long*));

---

Once you have that, you can allocate each of the 10 arrays. For example, if each array element is a pointer to 15 longs

Code:

---

int i,j;

...
for(i = 0; i < 10; i++)
  ptrone[i] = malloc( 15 * sizeof(long) );

//or if you prefer to use calloc
for(i = 0; i < 10; i++)
  ptrone[i] = calloc( 15, sizeof(long) );

---

I'm supprised your compiler didn't complain about the return value of function newFT(). :rolleyes: