An array of existing arrays

Question

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?

Answer 1

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.

Answer 2

Yes, you can ( both ways )

You need

typedef byte sometype[4][2];

However, you'll probably need the size of lines, circles, etc. , which is lost by a pointer.

One way might be an end marker (A special element, indicating there are no more) Another might be a

struct sometype {
  size_t n;
  byte [][4][2] data;
} lines ;

IMO, even 2D arrays are reaching the limits of human intelligence, and I'd prefer even more user defined types:

typedef byte Pattern[4][2]; // or a more appropriate name

Pattern lineArray[] { 
             { {B00000000, B11110000 }, 
               {B00000000, B11110000 }, 
               {B00000000, B11110000 }, 
               {B00000000, B11110000 } }
          , { {B11110000, B00000111 }, 
               {B00000000, B11111000 }, 
               {B00000000, B11111000 }, 
               {B00000000, B11111000 } }
};

typedef struct { 
  size_t count;
  Pattern* data;
} PatternCollection; 

PatternCollection lines = {sizeof(lineArray)/sizeof(Pattern), lineArray };

PatternCollection sequence[] = {lines /* , circles, squares */ }; // if you ever need to iterate them