Pointer to an array type (custom types)

How do I assign a value to the pointer of the custom array type so I can iterate through the array using the pointer?

Given array_type defined by

typedef int array_type[3];

, the pointer type to which you can assign an array_type is int *:

typedef int *ptr_array_element;

You can (seemingly) assign an object of array_type to a pointer of type ptr_array_element:

array_type a = {2, 3, 4};
ptr_array_element p = a;

Having done so, you can access the first array element via the derferencing operator.

assert(*p == 2);

And you can generally use it a bit like a C++ iterator:

printf("%d\n", *p++);
printf("%d\n", *p++);
printf("%d\n", *p++);

BUT DON'T.

Use typedefs sparingly, where they hide irrelevant detail, substantially improve code clarity, or similar. Avoid using typedefs that obscure relevant details, such as that objects of that type are pointers or arrays, unless, possibly, those details are abundantly clear from the type names, or unless hiding them is intentional and harmless. It is rarely harmless to hide array or pointer nature.

ptr is a pointer to int[3]; a is an int[3]. While I don't like typedefing pointer types in general, if you insist on this approach, here's how you can dereference into the first element of a from ptr:

ptr = &a;
printf("%d\n", **ptr);

ptr_array_type aliases int (*)[3], not int * - you will not be able to use it to iterate through array_type. You could use it to iterate through an array of array_type, like so:

array_type arr[3];
ptr_array_type ptr = arr;

while ( size_t i = 0; i < 3; i++ )
  do_something_with( ptr[i] );

If you want to be able to iterate through an array of T with a pointer, then the type of that pointer must be T *. So you'd need to change your typedefs to something like

typedef int array_type[3];    // probably want to replace int with another
typedef int *ptr_array_type;  // typedef to abstract out the type
...
array_type a = {1, 2, 3}; // yuck! don't do this! a is not obviously an array,
                          // so an array initializer looks wrong in this context
ptr_my_type p = a;

printf( "%d", *p );

However...

If you're using typedef to abstract away implementation details for a type, then you should abstract away all implementation details for that type, including things like dereferencing and subscripting. You'll want to create a full API, such as:

 array_type *arr = new_array_type( 1, 2, 3 );  // even this is leaky since it assumes we know
                                               // the array element type is integral
 array_type_iterator *itr = new_array_type_iterator( arr );
 array_element_type target;

 begin_iterator( &itr ); 
 while( next_iterator( &itr ) )
 {
   get_data_from_iterator( itr, &target );
   write_array_element_to( stdout, target );
 }

 free_array_type_iterator( itr );
 free_array_type( arr );

Partial or leaky abstractions just lead to code that's confusing to use and maintain. If the user of a type has to be aware of that type's "array-ness" or "pointer-ness" in order to use it properly, then don't hide those qualities behind a typedef without providing replacements for the [] and unary * operators as well. Also provide some way to abstract out I/O - don't force the user to have to know whether to use %d or %f or %s in a printf statement if they're not working with a primitive type.