Объектно-ориентированная таблица переходов, определенная для нескольких классов

Я собираюсь продвигать свой комментарий к ответу: объектно-ориентированное решение, как вы говорите, дает дочерним классам полную ответственность за решение, на какие коды операций они реагируют.

Я бы предположил, что самый простой способ сделать это — не пытаться построить двухэтапный switch, а просто направить каждый код операции каждому дочернему элементу и позволить дочернему элементу либо внести свой вклад, либо нет. Это минимально жизнеспособное решение.

Если вам нужна оптимизация, то проще всего будет переформулировать:

void CBranchInstHandler::execute() {
    switch(_opcode) {
        case 0x90:
            this->BCC();
            break;
            ... etc ...
    }
}

To:

FuncPtr CBranchInstHandler::execute() {
    switch(_opcode) {
        case 0x90:
            return BCC;
            ... etc ...
    }
    return NULL;
}

Таким образом, каждый execute возвращает, действительно ли он обработал этот код операции.

В родительском классе вы можете просто сохранить таблицу от кода операции до указателя на функцию. Подойдет массив. Изначально таблица будет содержать NULLs.

При выполнении кода операции найдите обработчик в таблице. Если обработчик есть, вызовите его и двигайтесь дальше. Если нет, то вызовите execute для каждого дочернего элемента по очереди, пока кто-то не вернет обработчик, затем поместите их в таблицу и затем вызовите ее. Таким образом, вы создадите его точно в срок, во время выполнения. Первый запуск каждого кода операции займет немного больше времени, но впоследствии у вас будет таблица переходов.

Преимущество этого заключается в том, что он позволяет тесно связать информацию о том, что обрабатывает дочерний элемент, с фактической обработкой этого синтаксически, уменьшая накладные расходы на код и вероятность ошибки.

Насколько я понимаю, вы создаете класс для каждого типа инструкций (ветвь, арифметика, загрузка, сохранение и т. д.), а затем внутри них вы пишете функции-члены для отдельных инструкций - c.f. у вас есть «CBranchInstrHandler», который обрабатывает «ветвь при переносе», «ветвь на нуле» и т. д.?

Полностью объектно-ориентированный подход заключается в расширении вашего подкласса до отдельных инструкций.

class CBranchInstrHandler { virtual void execute() = 0; };
class CBranchOnCarryClear : public CBranchInstrHandler {
    void execute() override {
        ...;
    }
};
class CBranchOnCarrySet : public CBranchInstrHandler {
    void execute() override {
        ...;
    }
};

Теперь вы можете просмотреть свои инструкции одним выстрелом, но вам потребуется сопоставление всех этих элементов один к одному.

switch (opCode) {
    case 0x90: return .. CBranchOnCarryClear .. ;
    case 0xB0: return .. CBranchOnCarrySet .. ;
}

Многоточие здесь, потому что я не уверен, как вы получаете указатель на свой CBranchInstrHandler; Я предполагаю, что они статичны и что вы не new используете их каждую инструкцию.

Если они не содержат данных, вы можете вернуть их как объекты функций по значению:

struct Base { virtual void execute() { /* noop */ } };
struct Derived { void execute(override) { ... } };

Base getHandler(opcode_t opcode) {
    if (opcode == 1) { return Derived(); }
}

но я подозреваю, что вы, вероятно, захотите взять параметры и сохранить состояние, и в этом случае возврат по значению здесь может привести к нарезке.

Конечно, если вы используете С++ 11, вы можете использовать лямбда-выражения:

switch (opCode) {
    case 0x90: return [this] () {
        ... implement BCC execute here ...
    };
    case 0xB0: return [this] () {
        ... implement BCS execute here ...
    }
}

Вы можете использовать указатель на функцию/метод класса:

void (CBranchHandlerBase::*)();

Использование для хранения указателей на методы, которые должны быть вызваны для данного _opcode.

map<uint8_t, void (CBranchHandlerBase::*)()> handlers;
handlers[0x90] = &BCC;
handlers[0xb0] = &BCS;
...

Приведенный выше код должен быть предоставлен в разделе/методе инициализации внутри вашего базового класса для обработчиков. Конечно, BCC, BCS и т. д. должны быть объявлены как чисто виртуальные методы, чтобы подход работал.

Затем вместо вашего переключателя:

void CBranchHandlerBase::execute() {
    (this->*handlers[_opcode])();
}

Обратите внимание, что выполнение определено в базовом классе (и оно не обязательно должно быть виртуальным! Поскольку каждый обработчик будет иметь одинаковую функциональность метода выполнения).

Редактировать. Карта фактически может быть заменена вектором или массивом размера: 2^(8*sizeof(uint8_t)) по соображениям эффективности.