Como evitar a cadeia if / else if ao classificar um título em 8 direções?

Eu tenho o seguinte código:

if (this->_car.getAbsoluteAngle() <= 30 || this->_car.getAbsoluteAngle() >= 330)
  this->_car.edir = Car::EDirection::RIGHT;
else if (this->_car.getAbsoluteAngle() > 30 && this->_car.getAbsoluteAngle() <= 60)
  this->_car.edir = Car::EDirection::UP_RIGHT;
else if (this->_car.getAbsoluteAngle() > 60 && this->_car.getAbsoluteAngle() <= 120)
  this->_car.edir = Car::EDirection::UP;
else if (this->_car.getAbsoluteAngle() > 120 && this->_car.getAbsoluteAngle() <= 150)
  this->_car.edir = Car::EDirection::UP_LEFT;
else if (this->_car.getAbsoluteAngle() > 150 && this->_car.getAbsoluteAngle() <= 210)
  this->_car.edir = Car::EDirection::LEFT;
else if (this->_car.getAbsoluteAngle() > 210 && this->_car.getAbsoluteAngle() <= 240)
  this->_car.edir = Car::EDirection::DOWN_LEFT;
else if (this->_car.getAbsoluteAngle() > 240 && this->_car.getAbsoluteAngle() <= 300)
  this->_car.edir = Car::EDirection::DOWN;
else if (this->_car.getAbsoluteAngle() > 300 && this->_car.getAbsoluteAngle() <= 330)
  this->_car.edir = Car::EDirection::DOWN_RIGHT;

Eu quero evitar a ifcorrente s; é muito feio. Existe outra maneira, possivelmente mais limpa, de escrever isso?

#include <iostream>

enum Direction { UP, UP_RIGHT, RIGHT, DOWN_RIGHT, DOWN, DOWN_LEFT, LEFT, UP_LEFT };

Direction GetDirectionForAngle(int angle)
{
    const Direction slices[] = { RIGHT, UP_RIGHT, UP, UP, UP_LEFT, LEFT, LEFT, DOWN_LEFT, DOWN, DOWN, DOWN_RIGHT, RIGHT };
    return slices[(((angle % 360) + 360) % 360) / 30];
}

int main()
{
    // This is just a test case that covers all the possible directions
    for (int i = 15; i < 360; i += 30)
        std::cout << GetDirectionForAngle(i) << ' ';

    return 0;
}

É assim que eu faria. (De acordo com meu comentário anterior).

Você pode usar map::lower_bounde armazenar o limite superior de cada ângulo em um mapa.

Exemplo de trabalho abaixo:

#include <cassert>
#include <map>

enum Direction
{
    RIGHT,
    UP_RIGHT,
    UP,
    UP_LEFT,
    LEFT,
    DOWN_LEFT,
    DOWN,
    DOWN_RIGHT
};

using AngleDirMap = std::map<int, Direction>;

AngleDirMap map = {
    { 30, RIGHT },
    { 60, UP_RIGHT },
    { 120, UP },
    { 150, UP_LEFT },
    { 210, LEFT },
    { 240, DOWN_LEFT },
    { 300, DOWN },
    { 330, DOWN_RIGHT },
    { 360, RIGHT }
};

Direction direction(int angle)
{
    assert(angle >= 0 && angle <= 360);

    auto it = map.lower_bound(angle);
    return it->second;
}

int main()
{
    Direction d;

    d = direction(45);
    assert(d == UP_RIGHT);

    d = direction(30);
    assert(d == RIGHT);

    d = direction(360);
    assert(d == RIGHT);

    return 0;
}

Crie uma matriz, cada elemento associado a um bloco de 30 graus:

Car::EDirection dirlist[] = { 
    Car::EDirection::RIGHT, 
    Car::EDirection::UP_RIGHT, 
    Car::EDirection::UP, 
    Car::EDirection::UP, 
    Car::EDirection::UP_LEFT, 
    Car::EDirection::LEFT, 
    Car::EDirection::LEFT, 
    Car::EDirection::DOWN_LEFT,
    Car::EDirection::DOWN, 
    Car::EDirection::DOWN, 
    Car::EDirection::DOWN_RIGHT, 
    Car::EDirection::RIGHT
};

Então você pode indexar a matriz com o ângulo / 30:

this->_car.edir = dirlist[(this->_car.getAbsoluteAngle() % 360) / 30];

Nenhuma comparação ou ramificação necessária.

O resultado, entretanto, está um pouco diferente do original. Os valores nas bordas, ou seja, 30, 60, 120, etc. são colocados na próxima categoria. Por exemplo, no código original, os valores válidos de UP_RIGHTsão 31 a 60. O código acima atribui 30 a 59 a UP_RIGHT.

Podemos contornar isso subtraindo 1 do ângulo:

this->_car.edir = dirlist[((this->_car.getAbsoluteAngle() - 1) % 360) / 30];

Isso agora nos dá RIGHT30, UP_RIGHT60 etc.

No caso de 0, a expressão se torna (-1 % 360) / 30. Isso é válido porque -1 % 360 == -1e -1 / 30 == 0, portanto, ainda temos um índice de 0.

A seção 5.6 do padrão C ++ confirma este comportamento:

4 O /operador binário produz o quociente, e o %operador binário produz o resto da divisão da primeira expressão pela segunda. Se o segundo operando de /ou %for zero, o comportamento é indefinido. Para operandos integrais, o /operador produz o quociente algébrico com qualquer parte fracionária descartada. se o quociente a/bé representável no tipo do resultado, (a/b)*b + a%bé igual a a.

EDITAR:

Muitas questões foram levantadas em relação à legibilidade e manutenção de um construto como este. A resposta dada por motoDrizzt é um bom exemplo de simplificação da construção original que é mais sustentável e não é tão "feia".

Expandindo sua resposta, aqui está outro exemplo que faz uso do operador ternário. Como cada caso na postagem original é atribuído à mesma variável, o uso desse operador pode ajudar a aumentar a legibilidade ainda mais.

int angle = ((this->_car.getAbsoluteAngle() % 360) + 360) % 360;

this->_car.edir = (angle <= 30)  ?  Car::EDirection::RIGHT :
                  (angle <= 60)  ?  Car::EDirection::UP_RIGHT :
                  (angle <= 120) ?  Car::EDirection::UP :
                  (angle <= 150) ?  Car::EDirection::UP_LEFT :
                  (angle <= 210) ?  Car::EDirection::LEFT : 
                  (angle <= 240) ?  Car::EDirection::DOWN_LEFT :
                  (angle <= 300) ?  Car::EDirection::DOWN:  
                  (angle <= 330) ?  Car::EDirection::DOWN_RIGHT :
                                    Car::EDirection::RIGHT;

Esse código não é feio, é simples, prático, legível e fácil de entender. Ficará isolado em seu próprio método, então ninguém terá que lidar com isso no dia a dia. E apenas no caso de alguém ter que verificar - talvez porque ele está depurando seu aplicativo para um problema em outro lugar - é tão fácil que ele levará dois segundos para entender o código e o que ele faz.

Se eu estivesse fazendo esse tipo de depuração, ficaria feliz em não ter que gastar cinco minutos tentando entender o que sua função faz. A este respeito, todas as outras funções falham completamente, pois mudam uma rotina simples, esquecê-lo, livre de bugs, em uma bagunça complicada que as pessoas ao depurar serão forçadas a analisar e testar profundamente. Como gerente de projeto, ficaria muito chateado se um desenvolvedor pegasse uma tarefa simples e, em vez de implementá-la de uma maneira simples e inofensiva, perdesse tempo para implementá-la de uma forma complicada. Basta pensar o tempo todo que você perdeu pensando sobre isso, então chegando ao SO perguntando, e tudo apenas para piorar a manutenção e a legibilidade da coisa.

Dito isso, há um erro comum em seu código que o torna muito menos legível, e algumas melhorias que você pode fazer facilmente:

int angle = this->_car.getAbsoluteAngle();

if (angle <= 30 || angle >= 330)
  return Car::EDirection::RIGHT;
else if (angle <= 60)
  return Car::EDirection::UP_RIGHT;
else if (angle <= 120)
  return Car::EDirection::UP;
else if (angle <= 150)
  return Car::EDirection::UP_LEFT;
else if (angle <= 210)
  return Car::EDirection::LEFT;
else if (angle <= 240)
  return Car::EDirection::DOWN_LEFT;
else if (angle <= 300)
  return Car::EDirection::DOWN;
else if (angle <= 330)
  return Car::EDirection::DOWN_RIGHT;

Coloque isso em um método, atribua o valor retornado ao objeto, recolha o método e esqueça-o pelo resto da eternidade.

PS, há outro bug acima do limite de 330, mas não sei como você deseja tratá-lo, então não o corrigi de jeito nenhum.

Atualização posterior

De acordo com o comentário, você pode até mesmo se livrar do else:

int angle = this->_car.getAbsoluteAngle();

if (angle <= 30 || angle >= 330)
  return Car::EDirection::RIGHT;

if (angle <= 60)
  return Car::EDirection::UP_RIGHT;

if (angle <= 120)
  return Car::EDirection::UP;

if (angle <= 150)
  return Car::EDirection::UP_LEFT;

if (angle <= 210)
  return Car::EDirection::LEFT;

if (angle <= 240)
  return Car::EDirection::DOWN_LEFT;

if (angle <= 300)
  return Car::EDirection::DOWN;

if (angle <= 330)
  return Car::EDirection::DOWN_RIGHT;

Não o fiz porque sinto que a certo ponto se torna apenas uma questão de preferências próprias, e o escopo da minha resposta foi (e é) dar uma perspectiva diferente à sua preocupação sobre a "feiura do código". Enfim, como eu disse, alguém apontou nos comentários e acho que faz sentido mostrar.

Em pseudocódigo:

angle = (angle + 30) %360; // Offset by 30. 

Então, nós temos 0-60, 60-90, 90-150, ... como as categorias. Em cada quadrante com 90 graus, uma parte tem 60, uma parte tem 30. Então, agora:

i = angle / 90; // Figure out the quadrant. Could be 0, 1, 2, 3 

j = (angle - 90 * i) >= 60? 1: 0; // In the quardrant is it perfect (eg: RIGHT) or imperfect (eg: UP_RIGHT)?

index = i * 2 + j;

Use o índice em uma matriz contendo os enums na ordem apropriada.

switch (this->_car.getAbsoluteAngle() / 30) // integer division
{
    case 0:
    case 11: this->_car.edir = Car::EDirection::RIGHT; break;
    case 1: this->_car.edir = Car::EDirection::UP_RIGHT; break;
    ...
    case 10: this->_car.edir = Car::EDirection::DOWN_RIGHT; break;
}

Ignorando o primeiro, ifque é um caso um tanto especial, os demais seguem exatamente o mesmo padrão: um mínimo, máximo e direção; pseudo-código:

if (angle > min && angle <= max)
  _car.edir = direction;

Tornar este C ++ real pode ser parecido com:

enum class EDirection {  NONE,
   RIGHT, UP_RIGHT, UP, UP_LEFT, LEFT, DOWN_LEFT, DOWN, DOWN_RIGHT };

struct AngleRange
{
    int min, max;
    EDirection direction;
};

Agora, ao invés de escrever um monte de ifs, apenas faça um loop sobre suas várias possibilidades:

EDirection direction_from_angle(int angle, const std::vector<AngleRange>& angleRanges)
{
    for (auto&& angleRange : angleRanges)
    {
        if ((angle > angleRange.min) && (angle <= angleRange.max))
            return angleRange.direction;
    }

    return EDirection::NONE;
}

( throwIng uma excepção em vez de returning NONEé uma outra opção).

Que você chamaria de:

_car.edir = direction_from_angle(_car.getAbsoluteAngle(), {
    {30, 60, EDirection::UP_RIGHT},
    {60, 120, EDirection::UP},
    // ... etc.
});

Essa técnica é conhecida como programação baseada em dados . Além de eliminar um monte de ifs, permitiria que você adicionasse facilmente mais direções (por exemplo, NNW) ou reduzisse o número (esquerda, direita, para cima, para baixo) sem retrabalhar outro código.

(Lidar com seu primeiro caso especial é deixado como "um exercício para o leitor." :-))

Embora as variantes propostas com base em uma tabela de pesquisa angle / 30sejam provavelmente preferíveis, aqui está uma alternativa que usa uma pesquisa binária codificada para minimizar o número de comparações.

static Car::EDirection directionFromAngle( int angle )
{
    if( angle <= 210 )
    {
        if( angle > 120 )
            return angle > 150 ? Car::EDirection::LEFT
                               : Car::EDirection::UP_LEFT;
        if( angle > 30 )
            return angle > 60 ? Car::EDirection::UP
                              : Car::EDirection::UP_RIGHT;
    }
    else // > 210
    {
        if( angle <= 300 )
            return angle > 240 ? Car::EDirection::DOWN
                               : Car::EDirection::DOWN_LEFT;
        if( angle <= 330 )
            return Car::EDirection::DOWN_RIGHT;
    }
    return Car::EDirection::RIGHT; // <= 30 || > 330
}

Se você realmente deseja evitar a duplicação, pode expressar isso como uma fórmula matemática.

Em primeiro lugar, suponha que estamos usando @ Geek's Enum

Enum EDirection { RIGHT =0, UP_RIGHT, UP, UP_LEFT, LEFT, DOWN_LEFT,DOWN, DOWN_RIGHT}

Agora podemos calcular o enum usando matemática de inteiros (sem a necessidade de matrizes).

EDirection angle2dir(int angle) {
    int d = ( ((angle%360)+360)%360-1)/30;
    d-=d/3; //some directions cover a 60 degree arc
    d%=8;
    //printf ("assert(angle2dir(%3d)==%-10s);\n",angle,dir2str[d]);
    return (EDirection) d;
}

Como @motoDrizzt aponta, um código conciso não é necessariamente um código legível. Ele tem a pequena vantagem de expressá-lo como matemática torna explícito que algumas direções cobrem um arco mais amplo. Se você quiser seguir nessa direção, pode adicionar algumas declarações para ajudar a entender o código.

assert(angle2dir(  0)==RIGHT     ); assert(angle2dir( 30)==RIGHT     );
assert(angle2dir( 31)==UP_RIGHT  ); assert(angle2dir( 60)==UP_RIGHT  );
assert(angle2dir( 61)==UP        ); assert(angle2dir(120)==UP        );
assert(angle2dir(121)==UP_LEFT   ); assert(angle2dir(150)==UP_LEFT   );
assert(angle2dir(151)==LEFT      ); assert(angle2dir(210)==LEFT      );
assert(angle2dir(211)==DOWN_LEFT ); assert(angle2dir(240)==DOWN_LEFT );
assert(angle2dir(241)==DOWN      ); assert(angle2dir(300)==DOWN      );
assert(angle2dir(301)==DOWN_RIGHT); assert(angle2dir(330)==DOWN_RIGHT);
assert(angle2dir(331)==RIGHT     ); assert(angle2dir(360)==RIGHT     );

Tendo adicionado as declarações, você adicionou duplicação, mas a duplicação em declarações não é tão ruim. Se você tiver uma afirmação inconsistente, logo descobrirá. Asserts podem ser compilados fora da versão de lançamento para não sobrecarregar o executável que você distribui. No entanto, essa abordagem é provavelmente mais aplicável se você quiser otimizar o código em vez de apenas torná-lo menos feio.

Estou atrasado para a festa, mas poderíamos usar sinalizadores enum e checagem de alcance para fazer algo legal.

enum EDirection {
    RIGHT =  0x01,
    LEFT  =  0x02,
    UP    =  0x04,
    DOWN  =  0x08,
    DOWN_RIGHT = DOWN | RIGHT,
    DOWN_LEFT = DOWN | LEFT,
    UP_RIGHT = UP | RIGHT,
    UP_LEFT = UP | LEFT,

    // just so we be clear, these won't have much use though
    IMPOSSIBLE_H = RIGHT | LEFT, 
    IMPOSSIBLE_V = UP | DOWN
};

a verificação (pseudo-código), assumindo que o ângulo é absoluto (entre 0 e 360):

int up    = (angle >   30 && angle <  150) * EDirection.UP;
int down  = (angle >  210 && angle <  330) * EDirection.DOWN;
int right = (angle <=  60 || angle >= 330) * EDirection.Right;
int left  = (angle >= 120 && angle <= 240) * EDirection.LEFT;

EDirection direction = (Direction)(up | down | right | left);

switch(direction){
    case RIGHT:
         // do right
         break;
    case UP_RIGHT:
         // be honest
         break;
    case UP:
         // whats up
         break;
    case UP_LEFT:
         // do you even left
         break;
    case LEFT:
         // 5 done 3 to go
         break;
    case DOWN_LEFT:
         // your're driving me to a corner here
         break;
    case DOWN:
         // :(
         break;
    case DOWN_RIGHT:
         // completion
         break;

    // hey, we mustn't let these slide
    case IMPOSSIBLE_H:
    case IMPOSSIBLE_V:
        // treat your impossible case here!
        break;
}