Как избежать цепочки if / else if при классификации заголовка по 8 направлениям?

У меня такой код:

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;

Я хочу избежать ifцепочки s; это действительно некрасиво. Есть ли другой, возможно, более чистый способ написать это?

#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;
}

Вот как бы я это сделал. (Согласно моему предыдущему комментарию).

Вы можете использовать map::lower_boundи сохранять верхнюю границу каждого угла на карте.

Рабочий пример ниже:

#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;
}

Создайте массив, каждый элемент которого связан с блоком 30 градусов:

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
};

Затем вы можете проиндексировать массив с углом / 30:

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

Никаких сравнений или ветвлений не требуется.

Однако результат немного отличается от оригинала. Значения на границах, то есть 30, 60, 120 и т. Д., Помещаются в следующую категорию. Например, в исходном коде допустимые значения от UP_RIGHT31 до 60. Приведенный выше код присваивает от 30 до 59 UP_RIGHT.

Мы можем обойти это, вычтя 1 из угла:

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

Теперь мы получаем RIGHT30, UP_RIGHT60 и т. Д.

В случае 0 выражение становится (-1 % 360) / 30. Это верно, потому что -1 % 360 == -1и -1 / 30 == 0, поэтому мы все еще получаем индекс 0.

Раздел 5.6 стандарта C ++ подтверждает это поведение:

4 Бинарный /оператор дает частное, а бинарный %оператор дает остаток от деления первого выражения на второе. Если второй операнд /или %равен нулю, поведение не определено. Для целых операндов /оператор дает алгебраическое частное с отброшенной дробной частью. если частное a/bпредставимо в типе результата, (a/b)*b + a%bравно a.

РЕДАКТИРОВАТЬ:

Было поднято много вопросов относительно удобочитаемости и ремонтопригодности такой конструкции. Ответ, данный motoDrizzt, является хорошим примером упрощения исходной конструкции, которая более удобна в обслуживании и не так «уродлива».

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

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;

Этот код не уродлив, он простой, практичный, читаемый и легкий для понимания. Он будет изолирован в своем собственном методе, поэтому никому не придется иметь дело с ним в повседневной жизни. И на всякий случай, если кто-то должен это проверить - может быть, потому, что он отлаживает ваше приложение на предмет проблемы в другом месте - это настолько просто, что ему потребуется две секунды, чтобы понять код и то, что он делает.

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

Тем не менее, в вашем коде есть распространенная ошибка, которая делает его менее читабельным, и пару улучшений, которые вы можете легко сделать:

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;

Поместите это в метод, назначьте возвращаемое значение объекту, сверните метод и забудьте о нем на всю оставшуюся вечность.

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

Позднее обновление

Согласно комментарию, вы даже можете избавиться от 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;

Я не делал этого, потому что чувствую, что в какой-то момент это становится просто вопросом личных предпочтений, и объем моего ответа заключался (и есть) в том, чтобы дать другую точку зрения на вашу озабоченность «уродством кода». Во всяком случае, как я уже сказал, кто-то указал на это в комментариях, и я думаю, что есть смысл показать это.

В псевдокоде:

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

Итак, у нас есть 0-60, 60-90, 90-150... как категории. В каждом квадранте с 90 градусами одна часть - 60, другая - 30. Итак, теперь:

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;

Используйте индекс в массиве, содержащем перечисления в соответствующем порядке.

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;
}

Игнорируя ваше первое, ifчто является немного частным случаем, все остальные следуют одному и тому же шаблону: min, max и direction; псевдокод:

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

Реальный C ++ может выглядеть так:

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

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

Теперь, вместо того, чтобы писать кучу ifs, просто переберите свои различные возможности:

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;
}

( throwИНГ исключение , а не returnИнг NONEдругой вариант).

Что бы вы затем назвали:

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

Этот метод известен как программирование, управляемое данными . Помимо избавления от множества ifs, это позволит вам легко использовать добавление дополнительных направлений (например, NNW) или уменьшать число (влево, вправо, вверх, вниз) без переделки другого кода.

(Работа с вашим первым частным случаем остается «упражнением для читателя». :-))

Хотя предлагаемые варианты, основанные на таблице поиска angle / 30, вероятно, предпочтительны, вот альтернатива, которая использует жестко закодированный двоичный поиск, чтобы минимизировать количество сравнений.

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
}

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

Прежде всего, предположим, что мы используем Enum от @ Geek.

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

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

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;
}

Как указывает @motoDrizzt, краткий код не обязательно читаемый. У него есть небольшое преимущество в том, что его математическое выражение явно указывает на то, что некоторые направления покрывают более широкую дугу. Если вы хотите пойти в этом направлении, вы можете добавить несколько утверждений, которые помогут понять код.

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     );

Добавив утверждения, вы добавили дублирование, но дублирование в утверждениях не так уж и плохо. Если у вас есть непоследовательное утверждение, вы скоро узнаете. Утверждения могут быть скомпилированы вне версии выпуска, чтобы не раздувать исполняемый файл, который вы распространяете. Тем не менее, этот подход, вероятно, наиболее применим, если вы хотите оптимизировать код, а не просто сделать его менее уродливым.

Я опаздываю на вечеринку, но мы могли бы использовать флаги перечисления и проверки диапазона, чтобы сделать что-нибудь аккуратное.

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
};

проверка (псевдокод), предполагая абсолютный угол (от 0 до 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;
}