Trouble iterating struct - c++

Question

I have a bitfield struct called DescriptorByte aligned to 1 byte and a struct for holding lots of DescriptorByte like this:
struct DescriptorByte
{
unsigned char IsImmedCalc : 1;
unsigned char IsPrefix : 1;
unsigned char NoMemOp : 1;
unsigned char Size : 5;
};
struct OpcodeList
{
DescriptorByte ADD_EB_GB;
DescriptorByte ADD_EV_GV;
DescriptorByte ADD_GB_EB;
DescriptorByte ADD_GV_EV;
DescriptorByte ADD_8_OI = { TRUE, FALSE, TRUE, OPBASE + IMMED_8 };
DescriptorByte ADD_32_OI = { TRUE, FALSE, TRUE, OPBASE + IMMED_32 };
DescriptorByte PUSH_ES = { TRUE, FALSE, TRUE, OPBASE };
DescriptorByte POP_ES = { TRUE, FALSE, TRUE, OPBASE };
DescriptorByte OR_EB_GB;
//ETC
};
What i want to do is based on a number (byte) iterating through the struct like this:
OpcodeList opcodelist;
BYTE count = 5;
DescriptorByte = opcodelist + count;
Since the bitfield struct is aligned to 1 byte i should get the 5th element of the OpcodeList table, but i dont know how to make this on C++ i only know how to make it in ASM :/
LEA EAX, OPCODELIST
MOV ECX, COUNT
MOV EAX, DWORD PTR [EAX+ECX];
AND EAX, 0FF;
Thanks.

Answer 1

You are trying to access this "list" multiple ways: By name (like ADD_EB_GB), and by index. You can't do this with a struct.
I would suggest using a std::vector<DescriptorByte> (or std::array). This way you can access by index. And if you still need to access by name, make your names constant indices into this vector.
A bit like this:
typedef std::array<DescriptorByte, 9> OpcodeList;
enum OpcodeIndex
{
ADD_EB_GB = 0,
ADD_EV_GV,
ADD_GB_EB,
ADD_GV_EV,
ADD_8_OI,
ADD_32_OI,
PUSH_ES,
POP_ES,
OR_EB_GB
}
...
// instantiate & initialize an opcode list.
OpcodeList opcodeList =
{
{ ... },// ADD_EB_GB,
{ ... },// ADD_EV_GV,
{ ... },// ADD_GB_EB,
{ ... },// ADD_GV_EV,
{ TRUE, FALSE, TRUE, OPBASE + IMMED_8 },// ADD_8_OI,
{ TRUE, FALSE, TRUE, OPBASE + IMMED_32 },// ADD_32_OI,
{ TRUE, FALSE, TRUE, OPBASE },// PUSH_ES,
{ TRUE, FALSE, TRUE, OPBASE },// POP_ES,
{ ... }// OR_EB_GB
};
// to access by symbol:
DescriptorByte someOpcode = opcodeList[ADD_GV_EV];
// to access by symbol + offset:
DescriptorByte anotherOpcode = opcodeList[ADD_GV_EV + 5];
Note about performance. At the machine code level, a struct and a statically sized array will perform exactly the same. They are ptr+offset fields. This is exactly what std::array will compile into. std::vector will have more overhead because it supports varying sizes, so only use it if you will have OpcodeList objects that have different sizes.
Regarding initialization, it's true this is more verbose / uglier than what you have, but it's a worthy effort to keep things manageable.

Answer 2

You can also do this using your struct:
OpcodeList opcodelist;
BYTE count = 5;
void* p1 = &opcodelist;
DescriptorByte* p2 = (DescriptorByte*)p1;
DescriptorByte = *(p2 + count);