`template <class> lớp người bạn Foo` có nghĩa là gì?

Question

Tôi đang khám phá boost :: iterator_facade và tình cờ gặp chút mã này:

friend class boost::iterator_core_access; 
    template <class> friend class Iterator; 

không dòng thứ hai có ý nghĩa gì? Tôi quen thuộc với các lớp bạn bè, nhưng tôi không nghĩ rằng tôi đã nhìn thấy template <class> trước bất cứ điều gì trước đây.

---

Dưới đây là bối cảnh:

template <class Value> 
class node_iter 
    : public boost::iterator_facade< 
     node_iter<Value> 
     , Value 
     , boost::forward_traversal_tag 
    > 
{ 
public: 
    node_iter() 
     : m_node(0) {} 

    explicit node_iter(Value* p) 
     : m_node(p) {} 

    template <class OtherValue> 
    node_iter(node_iter<OtherValue> const& other) 
     : m_node(other.m_node) {} 

private: 
    friend class boost::iterator_core_access; 
    template <class> friend class node_iter; 

    template <class OtherValue> 
    bool equal(node_iter<OtherValue> const& other) const 
    { 
     return this->m_node == other.m_node; 
    } 

    void increment() 
    { m_node = m_node->next(); } 

    Value& dereference() const 
    { return *m_node; } 

    Value* m_node; 
}; 
typedef impl::node_iterator<node_base> node_iterator; 
typedef impl::node_iterator<node_base const> node_const_iterator; 

Answer 1

Nó chỉ có nghĩa là Iterator là một lớp mẫu với một mẫu tham số. Tình bạn được cấp cho tất cả các phiên âm của Iterator.

Iterator<int> là bạn của lớp học.

Iterator<bool> là bạn của lớp học.

...

Iterator<MyClass> là bạn của lớp học.

Bạn hiểu ý tưởng.

Ví dụ cách dùng

Giả sử bạn có một lớp mẫu Foo.

template <typename T> class Foo 
{ 
    public: 
     Foo() : data(0) {} 
    prvavte: 
     T data; 
}; 

Khi bạn nhanh chóng các lớp mẫu sử dụng:

Foo<int> a; 
Foo<float> b; 

bạn đang tạo hai lớp tại thời gian biên dịch. Foo<int> không có quyền truy cập vào phần riêng tư của Foo<float> và ngược lại. Đó là một sự bất tiện một số lần.

Bạn không thể làm:

b = a; // If you wanted to pull the data from a and put it in b. 

Thậm chí nếu bạn thêm một nhà điều hành bổ nhiệm vào ngạch,

template <typename T> class Foo 
{ 
    public: 
     Foo() : data(0) {} 
     template <typename T2> Foo& operator=(Foo<T2> const& rhs) 
     { 
     this->data = rhs.data; 
     return *this; 
     } 

    private: 
     T data; 
}; 

Nó sẽ không làm việc vì Foo<T> không có quyền truy cập vào các tin các phần của Foo<T2>. Để có được xung quanh mà bạn có thể sử dụng một tuyên bố bạn bè.

template <typename T> class Foo 
{ 
    public: 
     template <class> friend class Foo; 
     Foo() : data(0) {} 
     template <typename T2> Foo& operator=(Foo<T2> const& rhs) 
     { 
     this->data = rhs.data; 
     return *this; 
     } 

    private: 
     T data; 
}; 

Bây giờ, bạn có thể sử dụng:

Foo<int> a; 
Foo<float> b; 
b = a; 

Answer 2

Explicit õ: http://www.cplusplus.com/articles/1C75fSEw/

Nó cho phép bạn nhanh chóng các mẫu mà không thực sự sử dụng nó.