제목을 8 방향으로 분류 할 때 if / else if 체인을 피하는 방법은 무엇입니까?

다음 코드가 있습니다.

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;

나는 ifs 사슬 을 피하고 싶다 . 정말 못 생겼어요. 이것을 작성하는 또 다른, 아마도 더 깨끗한 방법이 있습니까?

#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_RIGHT은 31 ~ 60입니다. 위 코드는 30 ~ 59를 할당합니다.UP_RIGHT .

각도에서 1을 빼면이 문제를 해결할 수 있습니다.

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

이것은 이제 우리 RIGHT에게 30을줍니다.UP_RIGHT 60 등을 제공합니다.

0의 경우 표현식은 (-1 % 360) / 30. 이것은 유효하기 때문에 -1 % 360 == -1과-1 / 30 == 0 우리는 여전히 0의 인덱스를 얻을 수 있도록.

C ++ 표준 의 섹션 5.6 은이 동작을 확인합니다.

4 이항 /연산자는 몫을 산출하고 이항 %연산자는 첫 번째 표현식을 두 번째로 나눈 나머지를 산출합니다. /또는 의 두 번째 피연산자 %가 0이면 동작이 정의되지 않습니다. 정수 피연산자의 경우 /연산자는 분수 부분이 삭제 된 대수 몫을 산출합니다. 몫이 경우 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;

그 코드는 추악하지 않고 간단하고 실용적이며 읽기 쉽고 이해하기 쉽습니다. 그것은 자신의 방법으로 분리 될 것이므로 일상 생활에서 아무도 그것을 다룰 필요가 없을 것입니다. 그리고 누군가가 그것을 확인해야하는 경우에-아마도 그가 다른 곳에서 문제를 위해 당신의 응용 프로그램을 디버깅하고 있기 때문일 것입니다-코드와 그것이하는 일을 이해하는 데 2 ​​초가 걸릴 것입니다.

내가 그런 디버그를하고 있었다면 당신의 함수가 무엇을하는지 이해하려고 5 분을 할애하지 않아도 돼 기쁘다. 이와 관련하여 다른 모든 기능은 디버깅 할 때 사람들이 심도있게 분석하고 테스트해야하는 복잡한 혼란 속에서 간단하고 잊어 버리는 버그없는 루틴을 변경하므로 완전히 실패합니다. 프로젝트 관리자로서 저는 개발자가 간단한 작업을 수행하고이를 단순하고 무해한 방식으로 구현하는 대신 지나치게 복잡한 방식으로 구현하는 데 시간을 낭비하는 것에 크게 화가났습니다. 당신이 그것에 대해 생각하고, 그렇게 묻고, 그 일의 유지 보수와 가독성을 악화시키기 위해 낭비되는 모든 시간을 생각하십시오.

즉, 코드의 가독성을 떨어 뜨리는 일반적인 실수와 매우 쉽게 수행 할 수있는 몇 가지 개선 사항이 있습니다.

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;

이것을 메서드에 넣고 반환 된 값을 객체에 할당하고 메서드를 축소 한 다음 남은 영원 동안 잊어 버리십시오.

추신 : 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는 특별한 경우를 무시 하고 나머지는 모두 동일한 패턴을 따릅니다 : 최소, 최대 및 방향; 의사 코드 :

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

( throwing 대신 예외 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
}

정말로 중복을 피하고 싶다면 이것을 수학 공식으로 표현할 수 있습니다.

우선 @Geek의 Enum을 사용하고 있다고 가정합니다.

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