C / C++ / MFC

Stefan_Lang wrote:

You seem to understand the question as storing elements of different types

enum EMyColors {
   C_RED,
   C_GREEN,
   C_YELLOW
};
template <class Base, int n_elements>
class CMyArray1 {
   std::vector<Base> values;
public:
   CMyArray1() : values(n_elements) {} // initialize array of given size
   Base& operator[](const wchar_t wc) {
      size_t index = wc - L'a'; // 'a'-based index (or whatever...)
      assert(index < values.size());
      return values[index];
   }
};
template <class Base, int n_vectors, int n_elements>
class CMyArray2 {
   std::vector< CMyArray1<Base, n_elements> > vectors;
public:
   CMyArray2() : vectors(n_vectors) {} // initialize array of given size
   CMyArray1<Base, n_elements>& operator[](int i) {
      size_t index = i - 1; // 1-based index (or whatever...)
      assert(index < vectors.size());
      return vectors[index];
   }
};
template <class Base, int n_arrays, int n_vectors, int n_elements>
class CMyArray3 {
   std::vector< CMyArray2<Base, n_vectors, n_elements> > arrays;
public:
   CMyArray3() : arrays(n_arrays) {} // initialize array of given size
   CMyArray2<Base, n_vectors, n_elements>& operator[](EMyColors c) {
      size_t index;
      switch (c) {
      case C_RED:
         index = 0;
         break;
      case C_GREEN:
         index = 1;
         break;
      default:
         index = 2;
         break;
      }
      return arrays[index];
   }
};
int foo() {
   CMyArray3<int, 3, 5, 8> my_array;
   my_array[C_GREEN][3][L'c'] = 17;
}

enum MyEnum { X, Y, Z };

union MyUnion { 
   MyEnum _Enum;
   int _Int;
   const wchar *_Pwchar;
   };

MyUnion ary[3][6][7];

"Hi, I am a UDP message and I maybe get transmitted as multiple UDP packets"

"Hi, I am a UDP mes"
"sage and I maybe get transmitted as multiple U"
"DP packets"

// BYTE is a Windows typedef for unsigned char, and generally makes your purpose clearer
// PBYTE is a typedef for a BYTE*
PBYTE pCompleteBMPIMageData = new BYTE[size of header plus size of raw data];
memcpy(pCompleteBMPIMageData, reinterpret_cast<PBYTE>(&BITMAPINFO), sizeof BITMAPINFO);
memcpy(pCompleteBMPIMageData + sizeof BITMAPINFO, pRawBMPData, size of raw data);