Làm cách nào để tránh chuỗi if / else if khi phân loại tiêu đề thành 8 hướng?

Tôi có mã sau:

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;

Tôi muốn tránh ifchuỗi s; nó thực sự xấu xí. Có một cách viết khác, có thể rõ ràng hơn không?

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

Đây là cách tôi sẽ làm điều đó. (Theo nhận xét trước đây của tôi).

Bạn có thể dùng map::lower_bound và lưu trữ giới hạn trên của mỗi góc trong bản đồ.

Ví dụ làm việc bên dưới:

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

Tạo một mảng, mỗi phần tử trong số đó được liên kết với một khối 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
};

Sau đó, bạn có thể lập chỉ mục mảng với góc / 30:

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

Không cần so sánh hoặc phân nhánh.

Tuy nhiên, kết quả hơi khác so với ban đầu. Các giá trị trên đường viền, tức là 30, 60, 120, v.v. được đặt trong danh mục tiếp theo. Ví dụ: trong mã gốc, các giá trị hợp lệ UP_RIGHTlà 31 đến 60. Đoạn mã trên gán 30 đến 59 cho UP_RIGHT.

Chúng ta có thể giải quyết vấn đề này bằng cách trừ đi 1 cho góc:

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

Điều này hiện mang lại cho chúng tôi RIGHT30, UP_RIGHT60, v.v.

Trong trường hợp 0, biểu thức trở thành (-1 % 360) / 30. Điều này hợp lệ bởi vì -1 % 360 == -1và -1 / 30 == 0, vì vậy chúng tôi vẫn nhận được chỉ mục là 0.

Phần 5.6 của tiêu chuẩn C ++ xác nhận hành vi này:

4/ Toán tử nhị phân sinh ra thương số và %toán tử nhị phân sinh ra phần còn lại từ phép chia biểu thức đầu tiên cho biểu thức thứ hai. Nếu toán hạng thứ hai của /hoặc %bằng 0 thì hành vi không được xác định. Đối với toán hạng tích phân, toán /tử mang lại thương số đại số với bất kỳ phần phân số nào bị loại bỏ. nếu thương số a/bcó thể biểu diễn trong kiểu kết quả, (a/b)*b + a%bthì bằng a.

BIÊN TẬP:

Có rất nhiều câu hỏi được đặt ra liên quan đến khả năng đọc và khả năng bảo trì của một cấu trúc như thế này. Câu trả lời được đưa ra bởi motoDrizzt là một ví dụ điển hình về việc đơn giản hóa cấu trúc ban đầu dễ bảo trì hơn và không hoàn toàn là "xấu xí".

Mở rộng câu trả lời của anh ấy, đây là một ví dụ khác về việc sử dụng toán tử bậc ba. Vì mỗi trường hợp trong bài đăng gốc được gán cho cùng một biến, việc sử dụng toán tử này có thể giúp tăng khả năng đọc hơn nữa.

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;

Mã đó không xấu, nó đơn giản, thiết thực, dễ đọc và dễ hiểu. Nó sẽ được cô lập theo phương pháp riêng của nó, vì vậy sẽ không ai phải đối phó với nó trong cuộc sống hàng ngày. Và đề phòng trường hợp ai đó phải kiểm tra nó - có thể vì anh ta đang gỡ lỗi ứng dụng của bạn cho một vấn đề ở nơi khác - thật dễ dàng, anh ta sẽ mất hai giây để hiểu mã và nó làm gì.

Nếu tôi đang thực hiện gỡ lỗi như vậy, tôi rất vui vì không phải dành năm phút để cố gắng hiểu chức năng của bạn làm gì. Về mặt này, tất cả các chức năng khác đều thất bại hoàn toàn, vì chúng thay đổi một quy trình đơn giản, hay quên, không có lỗi, trong một mớ hỗn độn phức tạp mà mọi người khi gỡ lỗi sẽ buộc phải phân tích sâu và kiểm tra. Với tư cách là người quản lý dự án, tôi thực sự rất khó chịu khi một nhà phát triển nhận một nhiệm vụ đơn giản và thay vì triển khai nó một cách đơn giản, vô hại, lại lãng phí thời gian để thực hiện nó một cách quá phức tạp. Chỉ cần suy nghĩ về tất cả thời gian bạn đã lãng phí suy nghĩ về nó, sau đó đến SO hỏi, và tất cả chỉ vì lợi ích của việc bảo trì và khả năng đọc của nó tồi tệ hơn.

Điều đó nói rằng, có một lỗi phổ biến trong mã của bạn khiến nó trở nên khó đọc hơn và một vài cải tiến bạn có thể thực hiện khá dễ dàng:

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;

Đặt điều này vào một phương thức, gán giá trị trả về cho đối tượng, thu gọn phương thức và quên nó trong phần còn lại của vĩnh viễn.

Tái bút có một lỗi khác vượt ngưỡng 330, nhưng không biết bạn muốn xử lý như thế nào nên không sửa được.

Cập nhật sau

Theo nhận xét, bạn thậm chí có thể loại bỏ cái khác nếu ở tất cả:

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;

Tôi đã không làm điều đó vì tôi cảm thấy rằng một điểm nào đó nó trở thành vấn đề của sở thích riêng và phạm vi câu trả lời của tôi là (và đang) đưa ra một góc nhìn khác cho mối quan tâm của bạn về "sự xấu xí của mã". Dù sao, như tôi đã nói, ai đó đã chỉ ra điều đó trong các bình luận và tôi nghĩ việc thể hiện điều đó là rất hợp lý.

Trong mã giả:

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

Vì vậy, chúng tôi có 0-60, 60-90, 90-150, ... như các loại. Trong mỗi góc phần tư có 90 độ, một phần có 60, một phần có 30. Vì vậy, bây giờ:

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;

Sử dụng chỉ mục trong một mảng chứa các enum theo thứ tự thích hợp.

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

Bỏ qua iftrường hợp đầu tiên của bạn là trường hợp hơi đặc biệt, những cái còn lại đều tuân theo cùng một mẫu chính xác: min, max và hướng; mã giả:

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

Tạo C ++ thực này có thể trông giống như:

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

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

Bây giờ, thay vì viết một loạt các ifs, chỉ cần lặp lại các khả năng khác nhau của bạn:

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 một ngoại lệ thay vì returning NONElà một tùy chọn khác).

Sau đó bạn sẽ gọi:

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

Kỹ thuật này được gọi là lập trình hướng dữ liệu . Bên cạnh việc loại bỏ một loạt các ifs, nó sẽ cho phép bạn dễ dàng sử dụng thêm các chỉ đường (ví dụ: NNW) hoặc giảm số lượng (trái, phải, lên, xuống) mà không cần làm lại mã khác.

(Xử lý trường hợp đặc biệt đầu tiên của bạn được để như "một bài tập cho người đọc." :-))

Mặc dù các biến thể được đề xuất dựa trên bảng tra cứu angle / 30có lẽ là thích hợp hơn, nhưng đây là một giải pháp thay thế sử dụng tìm kiếm nhị phân được mã hóa cứng để giảm thiểu số lượng so sánh.

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
}

Nếu bạn thực sự muốn tránh trùng lặp, bạn có thể biểu thị điều này dưới dạng công thức toán học.

Trước hết, giả sử rằng chúng ta đang sử dụng @ Geek's Enum

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

Bây giờ chúng ta có thể tính toán enum bằng cách sử dụng toán học số nguyên (không cần đến mảng).

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

Như @motoDrizzt đã chỉ ra, mã ngắn gọn không nhất thiết phải là mã có thể đọc được. Nó có một lợi thế nhỏ là thể hiện nó dưới dạng toán học làm cho nó rõ ràng rằng một số hướng bao phủ một cung rộng hơn. Nếu bạn muốn đi theo hướng này, bạn có thể thêm một số xác nhận để giúp hiểu mã.

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

Sau khi thêm xác nhận, bạn đã thêm trùng lặp, nhưng trùng lặp trong xác nhận không quá tệ. Nếu bạn có một khẳng định không nhất quán, bạn sẽ sớm phát hiện ra. Các cảnh báo có thể được biên dịch từ phiên bản phát hành để không làm cồng kềnh tệp thực thi mà bạn phân phối. Tuy nhiên, cách tiếp cận này có lẽ áp dụng nhất nếu bạn muốn tối ưu hóa mã hơn là chỉ làm cho nó bớt xấu xí.

Tôi đến muộn bữa tiệc, nhưng Chúng tôi có thể sử dụng cờ enum và kiểm tra phạm vi để thực hiện một điều gì đó gọn gàng.

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

kiểm tra (mã giả), giả định góc là tuyệt đối (từ 0 đến 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;
}