// The structure (INT8U is an unsigned 8 bit character)
typedef struct
{
    INT8U ID;
    INT8U AnotherValue;
    INT8U NameString[20];
} ITEM_DEFINE_t;

// The first array
ITEM_DEFINE_t FirstItemDefinitionArray[2][4] = 
{
    {
        {0,  1,  "First Item"},
        {1,  1,  "Second Item"},
        {2,  1,  "Third Item"},
        {3,  1,  "Fourth Item"},
    },
    {
        {0,  2,  "First Item"},
        {1,  2,  "Second Item"},
        {2,  2,  "Third Item"},
        {3,  2,  "Fourth Item"},
    }
};

// The second array
ITEM_DEFINE_t SecondItemDefinitionArray[2][4] = 
{
    {
        {0,  3,  "First Item"},
        {1,  3,  "Second Item"},
        {2,  3,  "Third Item"},
        {3,  3,  "Fourth Item"},
    },
    {
        {0,  4,  "First Item"},
        {1,  4,  "Second Item"},
        {2,  4,  "Third Item"},
        {3,  4,  "Fourth Item"},
    }
};

// Ok this is one part of the problem.
// How do I define the pointer to correctly reference the array?
ITEM_DEFINE_t **ItemPointer;

// This is the next part.
// How do I correctly set the pointer to reference the array?
ItemPointer = SecondItemDefinitionArray;

// The final part, and the part that I have the least problem with
// How do I correctly reference a member in the structure that the pointer is pointing too?
printf ("%s", ItemPointer[1][1]->NameString);

#include <stdio.h>

int main()
{
    char MyArray[] = "Hello World"; 
    
    //To get to the fist element using the [] notation you would do this
    printf("%c\n", MyArray[0]);

    //That would print n, but what if i wanted to use a pointer to 
    //do the same thing
    printf("%c\n", *(MyArray)); 
    //That will produce the same result as before printing a "H"

    //Now what if i wanted to get to the second character(second index)
    printf("%c\n", MyArray[1]);
    printf("%c\n", *(MyArray + 1));
    //All i did here was add one to the address and C is smart enough to
    //move the pointer along to the start of the next value. It does not matter
    // if the size of each element is one byte or 10 bytes it will always work.
}

#include <stdio.h>

int main()
{
    char MyArray[3][3] = {
                                     {'1', '2', '3'}
                                     {'4', '5', '6'}
                                     {'7', '8', '9'}
                                  };
    //First lets look at the address of MyArray
    printf("%p\n", MyArray);
    //Now lets look at the adress of MyArray[0][0]
    printf("%p\n", &MyArray[0][0]);
    //Now lets see what is in MyArray[0]
    printf("%p\n", MyArray[0]);

    //If you run that code what will be printed?

   //They will all print the same memory address as simple a 2D array
   // is just an array of arrays. 

   //Take a look at the values in MyArray

   printf("%c\n", MyArray[0][0]);
   printf("%c\n", *MyArray[0]);
   printf("%c\n", **MyArray);
  
   //This should all print 1 as they all refer to the same location. 

 
}

my_type** pointer_to_2d_array = my_2d_array;

ITEM_DEFINE_t (*ItemPointer)[4];
ItemPointer = SecondItemDefinitionArray;
printf ("%s", ItemPointer[1][1].NameString);

int main()
{
     int x;
     int *px = &x;      /* px contains the address of x  */
     *px = 2;            /*  sets x to be 2   */
}

int main()
{
     int array[5];
     int *px = x;        /* px contains the address of x[0] */
     *px = 2;            /*  sets x[0] to be 2   */
     *(px + 1) = 5     /*  sets x[1] to be 5 */
     px[1] = 5;         /*  does exactly the same thing as the previous line */
}

int main()
{
     int *px;             /* px is an uninitialised pointer */
     *px = 2;            /*  sets the value pointed at by px to be 2 */
     px[0] = 2;          /*   same as previous line */
}

int main()
{
     int x[3][4];    /* an array of 3 arrays of 4 ints */
     int (*px)[4];  /*  a pointer to an array of 4 ints */
     px = x;         /*  OK;  px is now an alias for x */
     px[1][2] = 5; /*  Sets x[1][2] to be 5 */
}

ITEM_DEFINE_t (*ItemPointer)[2][4];

ItemPointer = &SecondItemDefinitionArray[0][0];

ItemPointer = SecondItemDefinitionArray;

int *p = &(array_of_ints[0])

int *p = array_of_ints

int (*p)[5] = two_dimentional_array_of_ints