Anyone know how to convert this C/C++ initialiser?! { {0,0}, 0.5 }

[DruggedBunny Participant]

Hi all,

Does anyone know how to translate this C/C++ array initialisation (with nested {} braces) into a loop?

The struct is just an array of RGB values as integers, and I need to iterate through each, but I can’t tell what the init part is actually doing!

Monkey

struct MixingPlan { int colors[64]; }; MixingPlan result = { {0,0}, 0.5 };

1 2 3 4 5 6 7

struct MixingPlan { int colors[64]; };     MixingPlan result = { {0,0}, 0.5 };

How would I translate this to something like this?

Monkey

MixingPlan result; for (int loop, etc) { result.colors[loop] = er... }

1 2 3 4 5 6

MixingPlan result;   for (int loop, etc) { result.colors[loop] = er... }

I’m trying to port this palette/dither code to GLSL, so can’t use this style of initialiser, and I don’t understand what the {{0,0},0.5} thing is doing in regards to an integer value!

[Danilo]

When I search the site for “MixingPlan” I get more than one result, and it looks like you mix them up.

1st, 2nd, 3rd search result are in the same source code:

C++

struct MixingPlan { unsigned colors[2]; double ratio; /* 0 = always index1, 1 = always index2, 0.5 = 50% of both */ }; MixingPlan DeviseBestMixingPlan(unsigned color) { const unsigned r = color>>16, g = (color>>8)&0xFF, b = color&0xFF; MixingPlan result = { {0,0}, 0.5 };

1 2 3 4 5 6 7 8 9 10

struct MixingPlan {     unsigned colors[2];     double ratio; /* 0 = always index1, 1 = always index2, 0.5 = 50% of both */ }; MixingPlan DeviseBestMixingPlan(unsigned color) {     const unsigned r = color>>16, g = (color>>8)&0xFF, b = color&0xFF;     MixingPlan result = { {0,0}, 0.5 };

More search results containing “MixingPlan” show up.

Later there is a source code with a new MixingPlan struct:

C++

struct MixingPlan { const unsigned n_colors = 16; unsigned colors[n_colors]; }; MixingPlan DeviseBestMixingPlan(unsigned color) { MixingPlan result = { {0} };

1 2 3 4 5 6 7 8

struct MixingPlan {     const unsigned n_colors = 16;     unsigned colors[n_colors]; }; MixingPlan DeviseBestMixingPlan(unsigned color) {     MixingPlan result = { {0} };

 

Next one:

C++

typedef std::vector<unsigned> MixingPlan;

1	typedef std::vector<unsigned> MixingPlan;

 

And then, at round about the middle of the page (last search result):

C++

struct MixingPlan { unsigned colors[64]; }; MixingPlan DeviseBestMixingPlan(unsigned color) { MixingPlan result = { {0} };

1 2 3 4 5 6 7

struct MixingPlan {     unsigned colors[64]; }; MixingPlan DeviseBestMixingPlan(unsigned color) {     MixingPlan result = { {0} };

[DruggedBunny Participant]

Ah, thanks for pointing that out… the article is a little confusing, though I think the intent is to offer different options… I’ll look into that a little more closely.

Any idea on the initialisation part? I just don’t get this, and it’s not something easily searched-for!

Monkey

MixingPlan result = { {0,0}, 0.5 };

1	MixingPlan result = { {0,0}, 0.5 };

[Danilo]

This init part is for the struct with an array of 2 unsigned and 1 double.

C++

struct MixingPlan { unsigned colors[2]; double ratio; }; MixingPlan result = { {0,0}, 0.5 };

1 2 3 4 5 6 7 8

struct MixingPlan {     unsigned colors[2];     double ratio; };   MixingPlan result = { {0,0}, 0.5 };

 

Your struct colors[64] does not use such initialization:

C++

struct MixingPlan { unsigned colors[64]; }; MixingPlan result = { {0} };

1 2 3 4 5 6 7

struct MixingPlan {     unsigned colors[64]; };   MixingPlan result = { {0} };

 

As you can see, ‘ = { values }; ‘ is used for init, and the inner ‘{ values }’ is for array init.

 

See also: cppreference.com >> C reference >> initialization >> array initialization

Initialization from brace-enclosed lists

C++

int z[3] = {0}; // z has type int[3] and holds all zeroes

1	int z[3] = {0}; // z has type int[3] and holds all zeroes

Nested arrays

C++

int y[4][3] = { // array of 4 arrays of 3 ints each (4x3 matrix) { 1 }, // row 0 initialized to {1, 0, 0} { 0, 1 }, // row 1 initialized to {0, 1, 0} { [2]=1 }, // row 2 initialized to {0, 0, 1} }; // row 3 initialized to {0, 0, 0} struct { int a[3], b; } w[] = { { 1 }, 2 }; // array of structs // { 1 } is taken to be a fully-braced initializer for element #0 of the array // that element is initialized to { {1, 0, 0}, 0} // 2 is taken to be the first initialized for element #1 of the array // that element is initialized { {2, 0, 0}, 0}

1 2 3 4 5 6 7 8 9 10 11

int y[4][3] = { // array of 4 arrays of 3 ints each (4x3 matrix)     { 1 },      // row 0 initialized to {1, 0, 0}     { 0, 1 },   // row 1 initialized to {0, 1, 0}     { [2]=1 },  // row 2 initialized to {0, 0, 1} };              // row 3 initialized to {0, 0, 0}   struct { int a[3], b; } w[] = { { 1 }, 2 }; // array of structs    // { 1 } is taken to be a fully-braced initializer for element #0 of the array    // that element is initialized to { {1, 0, 0}, 0}    // 2 is taken to be the first initialized for element #1 of the array    // that element is initialized { {2, 0, 0}, 0}

[DruggedBunny Participant]

Oh, I see now! Thanks for that, Danilo, really appreciate it!

Hopefully I can get this converted today… thanks again.

[Author]

Posts