C / C++ / MFC

struct foo
{
    int first;
    int* second;
} fooArray[];

std::vector<FOO> foo2DArray[];

#define COMMAND_ARRAY 16
	struct ILI9341 {
		int Command;    // ILI9341 commands
		int* Data;      // ILI9341 data
	} ILI9341Array[COMMAND_ARRAY];

	// define/ assign Command
	int index = 0;
	int dataIndex = 0;
	int DefineCommand[COMMAND_ARRAY] = { 0x0, 0x1, 0x4 };
	int DefineData[][10] = { { 1, 2, 3, 4 }, { 5, 6, 7 }, { 9, 10, 11, 12, 13,
			14 } };
	for (index = 0; index != 3; index++) {
		ILI9341Array[index].Command = DefineCommand[index];
#ifdef DEBUG
		cout << "ILI9341Array[" << dec << +index << "] Command 0x" << hex
				<< ILI9341Array[index].Command << endl;
#endif
		ILI9341Array[index].Data = DefineData[index];
#ifdef DEBUG
		do {
			cout << "ILI9341Array[" << dec << +index << "] Data[" << dec
					<< +dataIndex << "] 0x" << hex
					<< ILI9341Array[index].Data[dataIndex] << endl;

		} while (ILI9341Array[index].Data[++dataIndex]);
		dataIndex = 0;
#endif

	}

#include <iostream>
 #include <iomanip>
 #include <map>
 #include <vector>

using namespace std;

 #define DEBUG

int main()
{
    map<int,vector<int>> IL9341Command = {{ {0x0, {{ 1, 2, 3, 4 }} },
                                            {0x1, {{ 4, 6, 7, }} },
                                            {0x4, {{ 9, 10, 11, 12, 13, 14 }} },
                                            {0xff, {{ 44, 55, 66, 77 }} } }};

 #ifdef DEBUG
    for(auto iter : IL9341Command) {
        cout << "IL9341Comand [ 0x" << hex << iter.first << " ] =";
        for(auto cmd : iter.second)
            cout << " 0x" << hex << cmd;
        cout << endl;
    }

    int *data = IL9341Command[0xff].data(); // get access to raw vector data

    cout << "\nCommand[0xff] data :";
    for(size_t i = 0; i < IL9341Command[0xff].size(); i++)
        cout <<  " 0x" << data[i];
    cout << endl;

 #endif // DEBUG

    return 0;
}

for(auto [key, data] : IL9341Command) {
        cout << "IL9341Comand [ 0x" << hex << key << " ] =";
        for(auto cmd : data)
            cout << " 0x" << hex << cmd;
        cout << endl;
    }

struct ILI9341 {
    uint8_t index;  // tracking index
    uint8_t Command; //
    uint8_t c_d;    // flag 0 command 1 data
    uint8_t *Data;  // data array
// data array format
// valid data count
// data...
// end marker
    char *Name;     // command name
    char *Function; // brief function description
    uint32_t delay = 0; // delay in uS after command
    char *RefPage;  // ILI9341 manual reference page
    char *Notes;    // misc notes
    uint8_t temp[COMMAND_ARRAY] = {}; // kluge
} ILI9341_CommandList[COMMAND_ARRAY];

uint8_t temp[3] = { 0x1, 0x0, 0xFF };
//int g_thing1array[3] = { 3, 4, 5 }; C example 
//thing g_thing1 = { 1, 2, g_thing1array };
ILI9341_CommandList[4].Data = temp;

struct ILI9341 {      // definition of the struct starts here
    uint8_t index;    // tracking index
    uint8_t Command;  //
    uint8_t c_d;      // flag 0 command 1 data
    uint8_t *Data;    // data array
// data array format
// valid data count
// data...
// end marker
    char *Name;       // command name
    char *Function;   // brief function description
    uint32_t delay;   // delay in uS after command
    char *RefPage;    // ILI9341 manual reference page
    char *Notes;      // misc notes
    uint8_t* temp;    // this should be a pointer to allow for variable length entries
} ILI9341_CommandList[COMMAND_ARRAY] = 
{                         // actual instances in the array are initialised here
    {       // first entry in the structure array
        0,                // tracking index
        0,                // Command
        0,                // flag 0 command 1 data
        buffer,           // data array buffer declared elsewhere as BYTE buffer[some number]
        "command name"    // command name
        "Function",       // brief function description
        100,              // delay in uS after command
        RefPage,          // ILI9341 manual reference page
        Notes,            // misc notes
        { 0x1, 0x0, 0xFF }    // command array - you may need a counter somewhere to indicate
                              //                 how many entries are in this array
    }, // end of the first entry
    {
         // other entries up to a maximum of COMMAND_ARRAY
    }
};

map<obj_a, vector<obj_b>>

bool operator<(const foo& other) const {}

Vaclav_ wrote:

PS I did try std:array , but it conflicts with "boost" - can't do for now.

The Observer pattern addresses the following problems:

    - A one-to-many dependency between objects should be defined without making the objects tightly coupled.
    - It should be ensured that when one object changes state an open-ended number of dependent objects are updated automatically.
    - It should be possible that one object can notify an open-ended number of other objects.

Quantum Robin wrote:

Reference: www.osmosian.com