Làm thế nào để tránh downcast?

Question

Tôi có triển khai một Mẫu nhà nước nơi mỗi tiểu bang xử lý các sự kiện mà nó nhận được từ hàng đợi sự kiện. Do đó, lớp cơ sở State có phương thức ảo thuần túy là void handleEvent(const Event*). Sự kiện kế thừa lớp cơ sở Event nhưng mỗi sự kiện chứa dữ liệu của nó có thể thuộc một loại khác (ví dụ: int, string ... hoặc bất kỳ thứ gì). handleEvent phải xác định loại thời gian chạy của sự kiện đã nhận và sau đó thực hiện downcast để trích xuất dữ liệu sự kiện. Các sự kiện được tạo và lưu trữ động trong hàng đợi (vì vậy, hãy upcasting diễn ra tại đây ...).

Tôi biết rằng downcasting là một dấu hiệu của một thiết kế xấu nhưng là nó có thể tránh nó trong trường hợp này? Tôi đang nghĩ đến Mô hình khách truy cập trong đó lớp cơ sở Nhà nước sẽ chứa trình xử lý ảo cho mỗi sự kiện nhưng sau đó một lần nữa sẽ cần phải diễn ra trong đoạn mã để loại bỏ sự kiện khỏi hàng đợi và chuyển nó tới trạng thái hiện tại. (Ít nhất trong trường hợp này lớn switch(eventID) sẽ chỉ ở một nơi ...). Mô hình khách truy cập là cách tốt nhất (thực hành tốt nhất) để tránh downcasting?

Đây là pseudo-code (tôi đi qua boost::shared_ptr trong ví dụ này nhưng downcasting xảy ra anyway):

enum EventID 
{ 
    EVENT_1, 
    EVENT_2, 
    ... 
}; 

class Event 
{ 
    EventID id; 
public: 
    Event(EventID id):id(id){} 
    EventID id() const {return id;} 
    virtual ~Event() = 0; 
}; 

class Event1 : public Event 
{ 
    int n; 
public: 
    Event1(int n):Event(EVENT_1), n(n){} 
    int getN() const {return n;} 
}; 

class Event2 : public Event 
{ 
    std::string s; 
public: 
    Event2(std::string s):Event(EVENT_2), s(s){} 
    std::string getS() const {return s;} 
}; 

typedef boost::shared_ptr<Event> EventPtr; 

class State 
{ 
    ... 
public: 
    ... 
    virtual ~State() = 0; 
    virtual void handleEvent(const EventPtr& pEvent) = 0; 
}; 

class StateA : public State 
{ 
    ... 
public: 
    void handleEvent(const EventPtr& pEvent) 
    { 
     switch(pEvent->id()) 
     { 
     case EVENT_1:   
      int n = boost::static_pointer_cast<Event1>(pEvent)->getN(); 
      ... 
      break; 
     case EVENT_2: 
      std::string s = boost::static_pointer_cast<Event2>(pEvent)->getS(); 
      ... 
      break; 
     ... 

     } 
    } 
} 

Answer 1

Các mẫu người truy cập điển hình thực hiện không yếu hèn, nhờ một chiến lược hai công văn:

// Visitor.hpp 
class EventBar; 
class EventFoo; 

class Visitor { 
public: 
    virtual void handle(EventBar const&) = 0; 
    virtual void handle(EventFoo const&) = 0; 
}; 

// Event.hpp 
class Visitor; 

class Event { 
public: 
    virtual void accept(Visitor&) const = 0; 
}; 

Và việc triển khai:

// EventBar.hpp 
#include <Event.hpp> 

class EventBar: public Event { 
public: 
    virtual void accept(Visitor& v); 
}; 

// EventBar.cpp 
#include <EventBar.hpp> 
#include <Visitor.hpp> 

void EventBar::accept(Visitor& v) { 
    v.handle(*this); 
} 

Điểm mấu chốt ở đây là ở v.handle(*this) loại tĩnh của *this là EventBar const&, chọn đúng quá tải virtual void handle(EventBar const&) = 0 quá tải trong Visitor.

Answer 2

Ý tưởng về các sự kiện là truyền các đối tượng chi tiết qua giao diện tổng quát (và thuyết bất khả tri). Downcast là không thể tránh khỏi và một phần của thiết kế. Xấu hay tốt, nó có thể tranh chấp.

Mẫu khách truy cập chỉ ẩn quá trình truyền khỏi bạn. Nó vẫn được thực hiện phía sau hậu trường, các loại được giải quyết thông qua địa chỉ phương thức ảo.

Vì Event của bạn đã có id, nó không hoàn toàn bất khả tri đối với loại, vì vậy việc truyền hoàn toàn an toàn. Ở đây bạn đang xem các loại cá nhân, trong mô hình khách truy cập bạn đang làm cho trình biên dịch chăm sóc đó.

"Bất cứ điều gì đi lên đều phải đi xuống".