Kết bạn với thông số mẫu

Question

Không thể kết bạn với thông số mẫu vì tiêu chuẩn không cho phép nó. Làm thế nào tôi có thể có được hiệu quả điều tương tự sau đó?

Điều tôi muốn về cơ bản là một loại không thể sử dụng được bên ngoài đối tượng sở hữu nó. Tại sao thay vì quan điểm nhưng nếu bạn thực sự phải biết, tôi đang cố gắng xây dựng một bộ con trỏ thông minh trả lời vấn đề chia sẻ tài nguyên sở hữu. Vì vậy những gì tôi đang tìm cách để làm một cái gì đó giống như vậy, nếu nó làm việc:

template < typename T, typename Owner > 
struct accessible_member 
{ 
private: 
    accessible_member() : val(T()) {} 
    accessible_member(T const& t) : val(t) {} 

    operator T&() { return val; } 
    operator T const&() const { return val; } 

    member_ptr<T> operator &() { return member_ptr<T>(val); } 

    friend class Owner; 
}; 

Vì vậy, một lớp không thể giữ đối tượng này như một thành viên trừ khi nó tuyên bố bản thân chủ sở hữu, và nếu nó đủ ngớ ngẩn để lộ nó như là, nó sẽ không thể sử dụng bên ngoài lớp học là ngu ngốc.

Answer 1

Bạn có thể sử dụng điều này, và sau đó cho phép tất cả các chủ sở hữu kế thừa từ Chủ sở hữu.

Sau đó, bạn có thể sử dụng lớp Chủ sở hữu để quấn riêng các phương pháp được sử dụng trong accessible_member.
có thể truy cập_member hiện có thể truy cập Chủ sở hữu. Bạn bè không được kế thừa, vì vậy bạn có thể cung cấp (bọc) các phương thức cần thiết để tất cả các lớp kế thừa Chủ sở hữu có thể sử dụng accessible_member.

Đó là giải pháp cấp 2 nhưng nó giữ mức đóng gói.

template < typename U > 
struct Owner 
{ 
    protected: 
    accessible_member<U> newAccessible_member() { return accessible_member<U>(); } 
    accessible_member<U> newAccessible_member(U const& u) { return accessible_member<U>(u); } 
    ..... 

}; 

template < typename T > 
struct accessible_member 
{ 
private: 
    accessible_member() : val(T()) {} 
    accessible_member(T const& t) : val(t) {} 

    operator T&() { return val; } 
    operator T const&() const { return val; } 

    member_ptr<T> operator &() { return member_ptr<T>(val); } 


    template < typename U> friend class Owner; 
}; 

Sau đó, bạn có thể sử dụng accessible_member gián tiếp trong cấu trúc mà kế thừa từ Chủ đầu tư sử dụng các phương pháp bảo vệ:

struct Blah: Owner<int> 
{ 
    void Dosomething() { 
     accessible_member<int> blah= newAccessible_member(); 
    } 
}; 

Nhìn vào ví dụ cuối cùng tại Template Friends.

Answer 2

Điều gì đơn giản là xác định loại lồng nhau riêng lẻ được kế thừa đáng kể từ access_member? Một cái gì đó giống như

class Owner 
{ 
    template < typename T > 
    class accessible_member : public ::accessible_member<T> {}; 
}; 

Tất nhiên điều đó vẫn có nghĩa là loại accessible_member gốc có sẵn cho bất kỳ ai để nó có thể không được sử dụng nhiều để nghĩ về nó.

Answer 3

Bạn đúng về C++ 98/03. Tuy nhiên C++ 0x (n3225 11.4/3) cho phép bạn làm điều này với cú pháp này:

friend Owner; 

Xem trình biên dịch của bạn có cho phép bạn làm điều đó không. Thử bật hỗ trợ C++ 0x. Nếu không thì cách giải quyết là xấu xí:

struct Owner 
{ 
    typedef Owner self; 
}; 

...

Sau đó, tùy thuộc vào trình biên dịch của bạn một trong số:

friend typename Owner::self; 

hay:

friend class Owner::self; 

Answer 4

7.1.5.3 p2 nói:

[Lưu ý: đây ngụ ý rằng, trong một mẫu lớp với một mẫu kiểu tham số T, việc kê khai lớp friend T; bị mờ.]

Kết quả là, bất kỳ giải pháp nào cho phép bạn thực hiện theo bất kỳ nghĩa nào sẽ không tuân thủ tiêu chuẩn.

Answer 5

Cách giải quyết duy nhất tôi có thể thấy là khá xấu xí và sử dụng CRTP:

template <typename T> 
struct CanUseAccessibleMember 
{ 
    template <typename T> 
    static const T& get(const accessible_member<T>& m) 
    { return static_cast<const T&>(m); } 

    // Etc. You can even specialize this class. 
}; 

struct ExampleOwner 
    : protected CanUseAccessibleMember<ExampleOwner> 
{ 
    // Do whatever you want with accessible members here 
    // but you have to use the get syntax 
}; 

template <typename T, typename Owner> 
class accessible_member 
{ 
    // Implement members as you did 

    friend struct CanUseAccessibleMember<Owner>; 
}; 

Answer 6

Điều đó sẽ làm việc, với một chút thay đổi, dưới C++ 98 như xa như tôi có thể nhìn thấy. Nó được biên soạn mà không cần bất kỳ cảnh báo cho tôi với g++-4.1 -Wall -Wextra -pedantic -ansi -std=c++98

Chỉ cần thay đổi

friend Owner; 

để

struct Wrapper { typedef Owner type; }; 
friend class Wrapper :: type; 

(tôi đã nhận rằng câu trả lời trên Stackoverflow, câu hỏi này đã đưa ra một vài lần: Template parameter as a friend)