Cho phép một lớp "bạn" chỉ truy cập một số thành viên riêng tư

Question

Giả sử tôi có ba lớp C++ FooA, FooB và FooC.

FooA có chức năng thành viên có tên Hello, tôi muốn gọi hàm này trong lớp FooB, nhưng tôi không muốn lớp FooC có thể gọi nó. Cách tốt nhất tôi có thể tìm ra để nhận ra điều này là tuyên bố FooB là một lớp người bạn của FooA. Nhưng miễn là tôi làm điều này, tất cả Thành viên riêng tư và được bảo vệ của FooA sẽ bị lộ diện, điều này hoàn toàn không thể chấp nhận đối với tôi.

Vì vậy, tôi muốn biết nếu có bất kỳ cơ chế nào trong C++ (03 hoặc 11) tốt hơn lớp học friend có thể giải quyết tình huống khó xử này.

Và tôi cho rằng nó sẽ được tốt đẹp nếu cú ​​pháp sau có thể:

class FooA 
{ 
private friend class FooB: 
    void Hello(); 
    void Hello2(); 
private: 
    void Hello3(); 
    int m_iData; 
}; 

class FooB 
{ 
    void fun() 
    { 
     FooA objA; 
     objA.Hello() // right 
     objA.Hello2() // right 
     objA.Hello3() // compile error 
     ojbA.m_iData = 0; // compile error 
    } 
}; 

class FooC 
{ 
    void fun() 
    { 
     FooA objA; 
     objA.Hello() // compile error 
     objA.Hello2() // compile error 
     objA.Hello3() // compile error 
     ojbA.m_iData = 0; // compile error 
    } 
}; 

Answer 1

Không có gì để làm cho một lớp là bạn của một chức năng cụ thể là, nhưng bạn có thể làm cho FooB một người bạn của một "chìa khóa" lớp với hàm tạo riêng, và sau đó có FooA::Hello lấy lớp đó làm tham số bị bỏ qua. FooC sẽ không thể cung cấp các thông số và do đó không thể gọi Hello:

Is this key-oriented access-protection pattern a known idiom?

Answer 2

Tôi nghĩ rằng bạn có thể sử dụng Attorney-Client đây.

Trong trường hợp ví dụ của bạn nên được như thế này

class FooA 
{ 
private: 
    void Hello(); 
    void Hello2(); 
    void Hello3(); 
    int m_iData; 

    friend class Client; 
}; 

class Client 
{ 
private: 
    static void Hello(FooA& obj) 
    { 
     obj.Hello(); 
    } 
    static void Hello2(FooA& obj) 
    { 
     obj.Hello2(); 
    } 
    friend class FooB; 
}; 

class FooB 
{ 
    void fun() 
    { 
     FooA objA; 
     Client::Hello(objA); // right 
     Client::Hello2(objA); // right 
     //objA.Hello3() // compile error 
     //ojbA.m_iData = 0; // compile error 
    } 
}; 

class FooC 
{ 
    void fun() 
    { 
     /*FooA objA; 
     objA.Hello() // compile error 
     objA.Hello2() // compile error 
     objA.Hello3() // compile error 
     ojbA.m_iData = 0; // compile error*/ 
    } 
}; 

Answer 3

Không, và điều này là không thực sự là một hạn chế. Theo tôi, giới hạn là friend - một vũ khí cùn để hacking xung quanh lỗi thiết kế - tồn tại ngay từ đầu.

lớp học của bạn FooA không có người kinh doanh biết về FooB và FooC và "cái nào sẽ có thể sử dụng nó". Cần có giao diện công khai và không quan tâm ai có thể sử dụng giao diện đó. Đó là điểm của giao diện! Các chức năng gọi điện trong giao diện đó phải luôn để lại trạng thái đẹp, an toàn, hài lòng, nhất quán.

Và nếu bạn lo ngại rằng bạn có thể vô tình sử dụng giao diện FooA từ một nơi nào đó bạn không có ý định, tốt, chỉ đơn giản là không làm điều đó; C++ không phải là ngôn ngữ phù hợp để bảo vệ chống lại các loại lỗi người dùng này. Phạm vi kiểm tra của bạn phải đủ trong trường hợp này.

Nói đúng ra, tôi chắc chắn bạn có thể có được chức năng mà bạn đang theo sau với một số mẫu thiết kế phức tạp "khủng khiếp" nhưng, thành thật mà nói, tôi sẽ không bận tâm.

Nếu đây là vấn đề đối với ngữ nghĩa của thiết kế chương trình của bạn, thì tôi lịch sự đề nghị rằng thiết kế của bạn có lỗi.

Answer 4

Toàn bộ ý tưởng của friend là để đưa lớp học của bạn cho bạn bè.

Có 2 cách bạn có thể cụ thể hơn về những gì bạn vạch trần:

1. Kế thừa từ FooA, rằng cách duy nhất bảo vệ và phương pháp nào được tiếp xúc.

2. Chỉ làm bạn với một phương pháp nhất định, như vậy chỉ có phương pháp đó sẽ có quyền truy cập:

.

friend void FooB::fun(); 

Answer 5

Các giải pháp an toàn nhất là sử dụng một lớp khác là "đi-giữa" cho hai lớp học của bạn, chứ không phải là làm cho một trong số họ một friend. Một cách để làm điều này được diễn tả bằng những câu trả lời bằng @ForEveR, nhưng bạn cũng có thể thực hiện một số tìm kiếm về các lớp proxy và các mẫu thiết kế khác có thể áp dụng.

Answer 6

Bạn sẽ cần kế thừa. Hãy thử điều này:

// _ClassA.h 
class _ClassA 
{ 
    friend class ClassA; 
private: 
    //all your private methods here, accessible only from ClassA and _ClassA. 
} 

// ClassA.h 
class ClassA: _ClassA 
{ 
    friend class ClassB; 
private: 
    //all_your_methods 
} 

Bằng cách này bạn có: ClassB là người duy nhất để có thể sử dụng ClassA. ClassB không thể truy cập _ClassA phương pháp, riêng tư.

Answer 7

Bạn có thể trưng ra một phần giao diện của lớp cho một máy khách được chỉ định bằng cách kế thừa nó từ một lớp giao diện.

class FooA_for_FooB 
{ 
public: 
    virtual void Hello() = 0; 
    virtual void Hello2() = 0; 
}; 

class FooA : public FooA_for_FooB 
{ 
private: /* make them private */ 
    void Hello() override; 
    void Hello2() override; 
private: 
    void Hello3(); 
    int m_iData; 
}; 

class FooB 
{ 
    void fun() 
    { 
     FooA objA; 
     FooA_for_FooB &r = objA; 
     r.Hello() // right 
     r.Hello2() // right 
     objA.Hello3() // compile error 
     objA.m_iData = 0; // compile error 
    } 
}; 

class FooC 
{ 
    void fun() 
    { 
     FooA objA; 
     objA.Hello() // compile error 
     objA.Hello2() // compile error 
     objA.Hello3() // compile error 
     objA.m_iData = 0; // compile error 
    } 
}; 

Kiểm soát truy cập này được tăng cường bởi lớp cơ sở FooA_for_FooB. Bằng cách tham chiếu loại FooA_for_FooB, FooB có thể truy cập các thành viên được xác định trong phạm vi FooA_for_FooB. Tuy nhiên, FooC không thể truy cập các thành viên đó vì chúng đã được ghi đè là thành viên riêng tư trong FooA. Mục đích của bạn có thể đạt được bằng cách không sử dụng loại FooA_for_FooB trong phạm vi FooC hoặc bất kỳ địa điểm nào khác ngoại trừ FooB, có thể được lưu giữ mà không chú ý nhiều.

Cách tiếp cận này không cần phải friend, giúp mọi việc trở nên đơn giản.

Điều tương tự có thể được thực hiện bằng cách đặt mọi thứ riêng tư trong lớp cơ sở và chọn lọc và hiển thị một số thành viên là công khai trong lớp dẫn xuất. Cách tiếp cận này đôi khi có thể yêu cầu downcast xấu xí, mặc dù. (Vì lớp cơ sở sẽ trở thành "tiền tệ" trong toàn bộ chương trình.)