Делая тяжелую функцию переключателя более пригодной для повторного использования

В C вы можете заменить переключатель на массив указателей на функции. В C ++ у вас есть дополнительная опция использования указателей на класс с полиморфным поведением.

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

typedef void (*disassembly_action)(uint8_t,uint8_t,uint8_t,uint8_t);

static void doSomethingOpcodeZero(uint8_t,uint8_t,uint8_t,uint8_t);
static void doSomethingOpcodeOne(uint8_t,uint8_t,uint8_t,uint8_t);
static void doSomethingOpcodeTwo(uint8_t,uint8_t,uint8_t,uint8_t);
static disassembly_action disassembly[] = {
doSomethingOpcodeZero
,   doSomethingOpcodeOne
,   doSomethingOpcodeTwo
,   ...
};

Теперь вы можете использовать индексирование массива вместо переключателя:

void ClassA::SomeFunction() {
uint8_t nibble1 = (opCode & 0xF000) >> 12;
uint8_t nibble2 = (opCode & 0x0F00) >> 8;
uint8_t nibble3 = (opCode & 0x00F0) >> 4;
uint8_t nibble4 = (opCode & 0x000F);
disassembly_action[something](nibble1, nibble2, nibble3, nibble4);
}

Вы можете создать аналогичный массив, чтобы заменить другой switch, возможно, используя другую подпись для вашего action функции.

Вот несколько быстрых подходов к использованию EventHandler для того, что вы можете зарегистрировать на маршрутизаторе, который что-то получает:

#include <iostream>
#include <vector>
#include <utility>

class SomethingHandler
{
public:
SomethingHandler() {}
~SomethingHandler() {}

virtual void handleSomething(int something)
{
doHandleSomething(something);
}

private:
virtual void doHandleSomething(int something) = 0;

};

class Router
{
public:
Router() {}

void registerHandlerForSomething(int somethingInteresting, SomethingHandler* h)
{
m_handler.push_back(std::pair<int,SomethingHandler*> (somethingInteresting, h));
}

void receive(int something) const
{
for(unsigned int i=0; i < m_handler.size(); ++i)
{
if(m_handler.at(i).first == something)
{
if(m_handler.at(i).second)
{
m_handler.at(i).second->handleSomething(something);
}
}
}
}

private:
std::vector< std::pair<int,SomethingHandler*> > m_handler;
};

class aHandler : public SomethingHandler
{
public:
aHandler() {}
private:
void doHandleSomething(int something)
{
std::cout << "handled something: " << something << "\n";
}
};

int main()
{
Router r;
aHandler h;

r.registerHandlerForSomething(42, &h);

r.receive(42);
}

это должно дать следующий вывод:

g++ main.cpp; ./a.out
handled something: 42

Вы можете изобрести специфичный для домена язык для описания операторов параллельного переключения, а затем преобразовать его в независимые операторы переключения с помощью сценария perl, вызываемого из Makefile.

Например:

BEGIN CASE 0x1
BEGIN FACET disassemble
// disassemble code for 0x1 goes here
END FACET
BEGIN FACET execute
// execute code goes for 0x1 here
END FACET
END CASE
BEGIN CASE 0x2
BEGIN FACET disassemble
// disassemble code for 0x2 goes here
END FACET
BEGIN FACET execute
// execute code for 0x2 goes here
END FACET
END CASE

Сценарий Perl может легко разделить аспекты на отдельные файлы:

disassemble.cc

case 0x1:
// disassemble code for 0x1 goes here
break;
case 0x2:
// disassemble code for 0x2 goes here
break;

execute.cc

case 0x1:
// execute code for 0x1 goes here
break;
case 0x2:
// execute code for 0x2 goes here
break;

Вы можете тогда #include случаи в соответствующие контексты переключения.

Что-то вроде этого:

#!/usr/bin/perl

our %bindings;
our $case;
our $binding;

while(<>) {
if(/^\s*BEGIN CASE (.*)$/) {
die "Unexpected BEGIN CASE" if defined $case;
$case = $1;
}
elsif(/^\s*END CASE$/) {
die "Unexpected END CASE" if !defined $case or $binding;
undef $case;
}
elsif(/^\s*BEGIN FACET (.*)$/) {
die "Unexpected BEGIN FACET" if !defined $case or $binding;
$binding = {case => $case, code => []};
push @{$bindings{$1}}, $binding;
}
elsif(/^\s*END FACET$/) {
die "Unexpected END FACET" unless $binding;
undef $binding;
}
elsif($binding) {
push @{$binding->{code}}, $_;
}
}

for my $facet (sort keys %bindings) {
print "#ifdef FACET_", uc($facet), "\n";
for my $binding (@{$bindings{$facet}}) {
print "case ", $binding->{case}, ":\n";
print $_ for (@{$binding->{code}});
print "break;\n";
}
print "#endif\n";
}