見出しを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_RIGHT31〜60です。上記のコードでは、30〜59をに割り当てていUP_RIGHTます。

これを回避するには、角度から1を減算します。

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

これRIGHTでUP_RIGHT、30、60などが得られます。

0の場合、式はになり(-1 % 360) / 30ます。これは-1 % 360 == -1および-1 / 30 == 0であるため有効であり、インデックス0を取得します。

C ++標準のセクション5.6は、この動作を確認しています。

4二項/演算子は商を生成し、二項%演算子は最初の式を2番目の式で除算した余りを生成します。/またはの2番目のオペランド%がゼロの場合、動作は未定義です。整数オペランドの場合、/演算子は、小数部分が破棄された代数商を生成します。商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分間費やす必要がないことを嬉しく思います。これに関して、他のすべての関数は完全に失敗します。それらは、デバッグの際に深く分析してテストすることを強いられる複雑な混乱の中で、単純で忘れがちなバグのないルーチンを変更するためです。私自身、プロジェクトマネージャーとして、開発者が単純なタスクを実行し、単純で無害な方法で実装するのではなく、過度に複雑な方法で実装するのに時間を浪費することに強く腹を立てます。あなたがそれについて考えて無駄な時間をすべて考えてから、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度の各象限では、1つの部分は60で、1つの部分は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;

enumを適切な順序で含む配列でインデックスを使用します。

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

（別のオプションthrowとして、returnING ではなく例外を使用し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;
}