Làm thế nào để tăng cường ràng buộc làm việc đằng sau hậu trường nói chung?

Question

Không tốn nhiều thời gian để xem xét mã nguồn tăng, ai đó có thể cho tôi một tóm tắt nhanh về cách liên kết tăng cường được thực hiện?

Answer 1

Tôi thích tác phẩm này của nguồn bind:

template<class R, class F, class L> class bind_t 
{ 
public: 

    typedef bind_t this_type; 

    bind_t(F f, L const & l): f_(f), l_(l) {} 

#define BOOST_BIND_RETURN return 
#include <boost/bind/bind_template.hpp> 
#undef BOOST_BIND_RETURN 

}; 

Cho bạn gần như tất cả các bạn cần phải biết, thực sự.

Tiêu đề bind_template mở rộng thành danh sách các định nghĩa nội tuyến operator(). Ví dụ, đơn giản nhất:

result_type operator()() 
{ 
    list0 a; 
    BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); 
} 

Chúng ta có thể thấy BOOST_BIND_RETURN nở vĩ mô để return vào thời điểm này do đó, dòng là giống như return l_(type...).

Một phiên bản tham số là ở đây:

template<class A1> result_type operator()(A1 & a1) 
{ 
    list1<A1 &> a(a1); 
    BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); 
} 

Nó khá giống nhau.

Lớp listN là trình bao bọc cho danh sách tham số. Có rất nhiều ma thuật sâu đang diễn ra ở đây mà tôi không thực sự hiểu quá nhiều. Chúng cũng đã quá tải operator() gọi hàm unwrap bí ẩn. Bỏ qua một số quá tải cụ biên dịch, nó không làm được rất nhiều:

ước

// unwrap 

template<class F> inline F & unwrap(F * f, long) 
{ 
    return *f; 
} 

template<class F> inline F & unwrap(reference_wrapper<F> * f, int) 
{ 
    return f->get(); 
} 

template<class F> inline F & unwrap(reference_wrapper<F> const * f, int) 
{ 
    return f->get(); 
} 

Việc đặt tên có vẻ là: F là kiểu của tham số chức năng để bind. R là kiểu trả về. L có xu hướng là danh sách các loại tham số. Ngoài ra còn có rất nhiều biến chứng vì không có ít hơn chín quá tải cho các số khác nhau của các tham số. Tốt nhất là không nên sống quá nhiều.

Answer 2

Tôi nghĩ rằng đó là một lớp mẫu tuyên bố biến thành viên cho các đối số bạn muốn ràng buộc và quá tải() cho phần còn lại của đối số.

Answer 3

Bằng cách này, nếu bind_t tính được thu nhỏ và đơn giản hóa bằng cách bao gồm boost/bind/bind_template.hpp, nó trở nên dễ hiểu như sau:

template<class R, class F, class L> 
class bind_t 
{ 
    public: 

     typedef bind_t this_type; 

     bind_t(F f, L const & l): f_(f), l_(l) {} 

     typedef typename result_traits<R, F>::type result_type; 
     ... 
     template<class A1> 
      result_type operator()(A1 & a1) 
      { 
       list1<A1 &> a(a1); 
       return l_(type<result_type>(), f_, a, 0); 
      } 
    private: 
     F f_; 
     L l_; 

};