Considere uma função que retorna o número de dias em um mês:

int obterDiasNoMes(int mes)
{
    int dias = 0;
    if(mes == 2)
    {
        dias = 28;
    }
    else if(mes == 4 || mes == 6 || mes == 9 || mes == 11)
    {
        dias = 30;
    }
    else
    {
        dias = 31;
    }
    return dias;
}

Esta abordagem utiliza números mágicos e múltiplas condições. Uma solução mais eficiente emprega uma tabela:

const int tabelaDias[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

int obterDiasNoMesPorTabela(int mes)
{
    return tabelaDias[mes - 1];
}

A técnica pode ser implementada de três formas principais:

Acesso Direto

O método mais simples, onde o índice é usado diretamente para acessar valores. Exemplo com sistema de informações sobre animais:

class Animal
{
public:
    virtual void exibir() = 0;
};

class Cao : public Animal
{
public:
    void exibir()
    {
        cout << "Animal: Cão" << endl;
    }
};

class Gato : public Animal
{
public:
    void exibir()
    {
        cout << "Animal: Gato" << endl;
    }
};

Animal* tabelaAnimais[] = {new Cao, new Gato};

int main()
{
    cout << "Selecione o animal:" << endl;
    cout << "1. Cão" << endl << "2. Gato" << endl;
    int opcao;
    cin >> opcao;
    tabelaAnimais[opcao - 1]->exibir();
}

Acesso por Índice

Útil quando há repetição de valores. Um índice mapeia para descrições compartilhadas:

const char* descricoes[] = {"Eletrônico", "Vestuário", "Alimentação"};
int indicesProdutos[] = {0, 1, 0, 2, 1}; // Múltiplos produtos apontam para mesma descrição

Acesso por Intervalos

Adequado para classifiacção em faixas de valores. Exemplo com conversão de notas:

const char notas[] = {'A', 'B', 'C', 'D', 'F'};
const int limites[] = {90, 80, 70, 60};

char converterNota(int pontuacao)
{
    for(int i = 0; i < 4; ++i)
    {
        if(pontuacao >= limites[i])
            return notas[i];
    }
    return 'F';
}

Para otimização em intervalos ordenados, pode-se aplicar busca binária:

int buscarClassificacao(int pontuacao)
{
    int inicio = 0;
    int fim = 3;
    while(inicio <= fim)
    {
        int meio = (inicio + fim) / 2;
        if(pontuacao >= limites[meio])
            return meio;
        else if(pontuacao < limites[meio])
            inicio = meio + 1;
        else
            fim = meio - 1;
    }
    return 4;
}

A técnica reduz complexidade ciclomática e possibilita otimizações como busca binária, diminuindo a complexidade temporal de O(N) para O(log N).