Loại bỏ đa hình theo cách thích hợp

Question

Tôi có một quá trình băm được thực hiện bằng cách sử dụng Howard Hinnant's method (băm chung dựa trên quá tải hash_append).

Mục đích của phương pháp đó là tạo băm lớp học để "ghi nhớ" kết quả tính toán (xem kết thúc câu trả lời này), vì vậy tôi đang gặp phải một số vấn đề. Đặc biệt, xem xét các lớp có thể Input sau đó cần phải được băm:

struct A { 
    virtual int do_stuff() const = 0; 
    virtual ~A(); 
}; 
struct B: A { 
    int do_stuff() const override { return 0; } 
}; 
struct C: A { 
    const int u; 
    int do_stuff() const override { return u; } 
}; 

struct Input { 
    A const& a; // store a reference to an instance of B or C 
}; 

Bây giờ, nếu tôi muốn băm Input, tôi sẽ có một cái gì đó như:

template <class HashAlgorithm> 
void hash_append(HashAlgorithm& h, Input const& input) { 
    hash_append(h, typeid(input)); 
    hash_append(h, typeid(input.a)); 
} 

Vì vậy, tôi cần một tình trạng quá tải của hash_append cho A:

template <class HashAlgorithm> 
void hash_append(HashAlgorithm& h, A const& a) { 
    hash_append(h, typeid(a)); 
} 

vấn đề ở đây là tùy thuộc vào loại thời gian chạy của a, tôi sẽ cần thêm thông tin bổ sung vào hàm băm, ví dụ: cho C Tôi cần phải thêm u.

Tôi nghĩ về các giải pháp sau (và nhược điểm):

1. thêm một phương pháp ảo để A mà trả về một giá trị cụ thể có thể được bổ sung vào typeid() băm, nhưng:

   • điều này có nghĩa là thêm một phương thức bên trong A không liên quan đến mục đích của A, do đó tôi không thực sự thích ý tưởng này (đặc biệt vì tôi có nhiều lớp giống như A);
   • điều này sẽ phá vỡ khái niệm hash_append vì phương thức này sẽ có kiểu trả về duy nhất cho tất cả các lớp kế thừa.

2. làm một loạt các dynamic_cast bên hash_append:

   • Tôi thấy điều này khá xấu xí ... đặc biệt là nếu tôi có nhiều lớp học tương tự như A;
   • điều này là dễ xảy ra lỗi: nếu ai đó thêm một trẻ em mới là A và không thêm dynamic_cast vào bên trong hash_append.

Có cách nào để băm một loại đa hình, mà không cần phải sửa đổi các loại bản thân hoặc dựa trên một loạt các dynamic_cast?

---

Mục tiêu cuối cùng là có thể ghi nhớ kết quả của một số chức năng nặng. Hãy phác thảo cấu trúc cơ bản của ứng dụng của tôi:

struct Input { }; 
struct Result { }; 

Result solve(Input const&); 

Chức năng solve là tính toán nặng, vì vậy tôi muốn lưu các kết quả tính toán trước đó trong tập tin sử dụng hash của Input s, ví dụcái gì đó như:

// depends on hash_append 
std::string hash(Input const&); 

Result load_or_solve(Input const& input) { 
    auto h = hash(input); 
    Result result; 
    if (exists(h)) { // if result exists, load it 
     result = load(h); 
    } 
    else { // otherwize, solve + store 
     result = solve(input); 
     store(h, result); 
    } 
    return result; 
} 

Các load và store phương pháp này sẽ tải và lưu trữ kết quả từ các tập tin, mục đích là để memoize giải pháp giữa chạy khác nhau.

Nếu bạn có đề xuất về cách ghi nhớ các kết quả này mà không phải giải quyết các vấn đề trên, tôi sẽ rất vui khi đọc chúng.

Answer 1

Bạn có thể sử dụng phép gửi kép trong phiên bản hash_append của A và chuyển tiếp yêu cầu đến phiên bản thích hợp (đó là phiên bản B hoặc C). Hạn chế là bạn phải thêm boilerplate vào các lớp đó để chấp nhận một khách truy cập và tôi không thể nói nếu nó có thể chấp nhận được cho bạn.
Đây là một loạt các mã mà nên minh họa cho ý tưởng:

struct B; 
struct C; 

struct Visitor { 
    virtual void visit(const B &) = 0; 
    virtual void visit(const C &) = 0; 
}; 

template<typename T, typename... O> 
struct HashVisitor: T, HashVisitor<O...> { 
    template<typename U> 
    std::enable_if_t<std::is_same<T, U>::value> tryVisit(const U &u) { 
     T::operator()(u); 
    } 

    template<typename U> 
    std::enable_if_t<not std::is_same<T, U>::value> tryVisit(const U &u) { 
     HashVisitor<O...>::visit(u); 
    } 

    void visit(const B &b) override { tryVisit<B>(b); } 
    void visit(const C &c) override { tryVisit<C>(c); } 
}; 

template<> 
struct HashVisitor<>: Visitor {}; 

template<typename... F 
auto factory(F&&... f) { 
    return HashVisitor<std::decay_t<F>>{std::forward<F>(f)...}; 
} 

struct A { 
    virtual void accept(Visitor &) = 0; 
    virtual int do_stuff() const = 0; 
    virtual ~A(); 
}; 

struct B: A { 
    void accept(Visitor &v) override { v.visit(*this); } 
    int do_stuff() const override { return 0; } 
}; 

struct C: A { 
    const int u; 
    void accept(Visitor &v) override { v.visit(*this); } 
    int do_stuff() const override { return u; } 
}; 

template <class HashAlgorithm> 
void hash_append(HashAlgorithm &, const B &) { 
    // do something 
} 

template <class HashAlgorithm> 
void hash_append(HashAlgorithm &, const C &) { 
    // do something 
} 

template <class HashAlgorithm> 
void hash_append(HashAlgorithm &h, const A &a) { 
    auto vis = factory(
     [&h](const B &b){ hash_append(h, b); }, 
     [&h](const C &c){ hash_append(h, c); } 
    ); 

    a.accept(vis); 
}