title: Passing an initialization list to an array member in C++
body: <p>When working with an aggregate class, passing in an initializer list for an array member is not problem. For example:</p>
  
  <pre><code>class color_def
  {
   public:
      const u8 color_passes;
      const u8 red_shift[MAX_COLOR_PASSES];
      const u8 red_bitcount[MAX_COLOR_PASSES];
      const u8 green_shift[MAX_COLOR_PASSES];
      const u8 green_bitcount[MAX_COLOR_PASSES];
      const u8 blue_shift[MAX_COLOR_PASSES];
      const u8 blue_bitcount[MAX_COLOR_PASSES];
  };
  
  const static color_def snk_neogeo_color = {
          3, {15, 14, 8}, {1, 1, 4}, {15, 13, 4}, {1, 1, 4}, {15, 12, 0}, {1, 1, 4}};
  </code></pre>
  
  <p>This works without any issue. However, when I add an explicit constructor, it won't work. For example, from a similar class:</p>
  
  <pre><code>class chr_def
  {
   public:
      chr_def(u16 width, u16 height, u8 bitplanes, u32 planeoffset[MAX_GFX_PLANES],
                      u32 xoffset[MAX_GFX_SIZE], u32 yoffset[MAX_GFX_SIZE],
                      const u8 *(*converter)(const chr_def *chrdef, const u8 *data))
              : width(width),
                  height(height),
                  bitplanes(bitplanes),
                  planeoffset{planeoffset},
                  xoffset(xoffset),
                  yoffset(yoffset),
                  converter(converter),
                  datasize(width * height * bitplanes){};
  
      const u8 *convert(const u8 *data) { return this-&gt;converter(this, data); }
  
      const u16 width;                 // pixel width of each element
      const u16 height;                // pixel height of each element
      const u8 bitplanes;          // number of color bitplanes
      const u32 *planeoffset; // bit offset of each bitplane
      const u32 *xoffset;          // bit offset of each horizontal pixel
      const u32 *yoffset;          // bit offset of each vertical pixel
      const u32 datasize;          // size of one chr in bits
      const u8 *(*converter)(const chr_def *, const u8 *);
  };
  
  const static chr_def nintendo_sfc = {
          8,
          8,
          4,
          {0, 8, 128, 136},
          {0, 1, 2, 3, 4, 5, 6, 7},
          {0 * 16, 1 * 16, 2 * 16, 3 * 16, 4 * 16, 5 * 16, 6 * 16, 7 * 16},
          get_chr};
  </code></pre>
  
  <p>The fails, complaining that the arguments don't match the constructor. The issue seems to be that it is taking the first value of the array init list as the pointer to the array:</p>
  
  <pre><code>note: candidate constructor not viable: cannot convert initializer list argument to 'u32 *' (aka 'unsigned int *')
  </code></pre>
  
  <p>If I pull the array init lists out and initialize them beforehand into their own variables like so:</p>
  
  <pre><code>u32 temp1[4] = {0, 8, 128, 136};
  u32 temp2[8] = {0, 1, 2, 3, 4, 5, 6, 7};
  u32 temp3[8] = {0 * 16, 1 * 16, 2 * 16, 3 * 16, 4 * 16, 5 * 16, 6 * 16, 7 * 16};
  const static chr_def nintendo_sfc = {
          8,
          8,
          4,
          temp1,
          temp2,
          temp3,
          get_chr};
  </code></pre>
  
  <p>Things work fine. I'd just really prefer <em>not</em> to do it this way if at all possible.</p>
  
  <p>So... why does this work in the aggregate form but not with my explicit constructor? Is there some way to make this work? Appreciate any insight anyone can offer.</p>