user11288: I have a bunch of 3D arrays in the following form:
byte lines[][4][2] {
                     { {B00000000, B11110000 }, 
                       {B00000000, B11110000 }, 
                       {B00000000, B11110000 }, 
                       {B00000000, B11110000 } },
                     { {B11110000, B00000111 }, 
                       {B00000000, B11111000 }, 
                       {B00000000, B11111000 }, 
                       {B00000000, B11111000 } },
// continues for numerous elements
                    }

They are a bunch of values to push out to a pair of shift registers controlling an LED matrix. Each array is essentially an animation that plays across the LED matrix.
I would like to put my collection of arrays into an array so I can iterate through them. I know I can just combine them into one big array but the code is already opaque and I would at least like to keep separate named arrays so I can sequence and rearrange a series of animations by rearranging a series of named arrays in another array rather than one massive array of opaque binary values. 
I want to do something like this
sometype* sequence[] = { lines, circles, squares } ;

or if that's not possible then:
sometype* sequence[3];
sometype[0] = lines;
sometype[1] = circles;
sometype[2] = squares;

Can I do this or some approximation thereof? If so what is "sometype"? I can't figure out how to say "an array of pointers to 3d byte arrays" or whatever it is I am trying to do. What is the syntax for deeclaring the array and dereferencing the pointers?

user7508: Try this:
byte (*sequence[])[4][2] = { lines, circles, squares } ;

Explanation: The identifiers lines, circles and squares decay
to pointers to the first element of each array. Their decayed types are
then “pointer to array of length 4 of array of length 2 of byte”. This
type could be declared as
typedef byte (*pointer_to_2d_array)[4][2];

The sequence is then an array of this type, which can be declared as
pointer_to_2d_array sequence[] = { ... };

or, if you appreciate the obscure elegance of the C syntax, as in the
beginning of this answer.

11288: <p>I have a bunch of 3D arrays in the following form:</p>

<pre><code>byte lines[][4][2] {
                     { {B00000000, B11110000 }, 
                       {B00000000, B11110000 }, 
                       {B00000000, B11110000 }, 
                       {B00000000, B11110000 } },
                     { {B11110000, B00000111 }, 
                       {B00000000, B11111000 }, 
                       {B00000000, B11111000 }, 
                       {B00000000, B11111000 } },
// continues for numerous elements
                    }
</code></pre>

<p>They are a bunch of values to push out to a pair of shift registers controlling an LED matrix. Each array is essentially an animation that plays across the LED matrix.</p>

<p>I would like to put my collection of arrays into an array so I can iterate through them. I know I can just combine them into one big array but the code is already opaque and I would at least like to keep separate named arrays so I can sequence and rearrange a series of animations by rearranging a series of named arrays in another array rather than one massive array of opaque binary values. </p>

<p>I want to do something like this</p>

<pre><code>sometype* sequence[] = { lines, circles, squares } ;
</code></pre>

<p>or if that's not possible then:</p>

<pre><code>sometype* sequence[3];
sometype[0] = lines;
sometype[1] = circles;
sometype[2] = squares;
</code></pre>

<p>Can I do this or some approximation thereof? If so what is "sometype"? I can't figure out how to say "an array of pointers to 3d byte arrays" or whatever it is I am trying to do. What is the syntax for deeclaring the array and dereferencing the pointers?</p>
 7508: <p>Try this:</p>

<pre class="lang-cpp prettyprint-override"><code>byte (*sequence[])[4][2] = { lines, circles, squares } ;
</code></pre>

<p><strong>Explanation</strong>: The identifiers <code>lines</code>, <code>circles</code> and <code>squares</code> decay
to pointers to the first element of each array. Their decayed types are
then “pointer to array of length 4 of array of length 2 of byte”. This
type could be declared as</p>

<pre class="lang-cpp prettyprint-override"><code>typedef byte (*pointer_to_2d_array)[4][2];
</code></pre>

<p>The sequence is then an array of this type, which can be declared as</p>

<pre class="lang-cpp prettyprint-override"><code>pointer_to_2d_array sequence[] = { ... };
</code></pre>

<p>or, if you appreciate the obscure elegance of the C syntax, as in the
beginning of this answer.</p>
