Apontando para os 'ADTs' definidos pelo Utilizador dentro de outro ' ADT ' em C

criei um tipo de dados abstractos em C que é baseado numa estrutura. Dentro desta estrutura, há ponteiros para outros ADTs que também são baseados fora de estruturas. Eu quero saber como / se eu posso inicializar corretamente os ponteiros no interior e se livrar de meus erros de violação de acesso à memória. O código é o seguinte:

typedef struct insideADT1_S{
     int someConstant1;
     int someArrray1[500];
} insideADT1_T

typedef struct insideADT2_S{
     int someConstant2;
     int someArray2[500];
} insideADT2_T

typedef struct outsideADT_S{
     insideADT1_T *insidePTR1;
     insideADT2_T *insidePTR2;
} outsideADT_T

Eu crio a estrutura externa e passo-a para uma função. Dentro da função, eu tento obter um dos membros internos, e eu cai e obter um erro de acesso à memória. Um exemplo está abaixo:

outsideADT_T *outsidePTR;
SomeFunction(&outsidePTR);

O interior de alguma função parece:

void SomeFunction(outsideADT_T *outsidePTR){
    //===Fill Array of Inside ADT===//
    for (i=0; i<500; i++){
        outsidePTR->insidePTR1->someArray1[i] = i;  //OOPS! Memory Access Violation! FAIL!
    }
}

No entanto, aceder assim dá-me violações de acesso à memória. Note que eu posso resolver o problema usando as versões da estrutura, em vez dos ADTs, e não definindo ponteiros para essas estruturas. Por exemplo:

typedef struct outsideADT_S{
     struct insideADT1_S insideSTC1;
     struct insideADT2_S insideSTC2;
} outsideADT_T

void SomeFunction(outsideADT_T *outsidePTR){
    //===Fill Array of Inside ADT===//
    for (i=0; i<500; i++){
        outsidePTR->insideSTC1.someArray1[i] = i;
    }
}

funciona bem. Porque é que o primeiro método falha quando o segundo não falha? O que estou a fazer mal da primeira vez, e como posso corrigi-lo?