Phương pháp C++ const trên thành phần con trỏ không const

Question

Tôi đã tự hỏi làm thế nào bảo vệ một thành viên con trỏ không const từ một đối tượng thông qua một phương pháp const. Ví dụ:

class B{ 
    public: 
     B(){ 
      this->val=0; 
     } 

     void setVal(){ 
      this->val = 2; 
     } 

    private: 
     int val; 
}; 

class A{ 
    public: 
     A():b(new B){} 
     void changeMemberFromConstMethod() const{ 
      this->b->setVal(); 
     } 
    private: 
     B * b; // how to protect data pointed in A::changeMemberFromConstMethod 
} 

Có thể "bảo vệ" dữ liệu A :: b được chỉ ra từ phương pháp của anh không? Sau nhiều nghiên cứu trên web, không có phản hồi hài lòng nào được tìm thấy.

Cảm ơn sự giúp đỡ của bạn.

Answer 1

Something như thế này, có lẽ:

template <typename T> 
class deep_const_ptr { 
    T* p_; 
public: 
    deep_const_ptr(T* p) : p_(p); 

    T* operator->() { return p_;} 
    const T* operator->() const { return p_;} 
}; 

class A { 
    deep_const_ptr<B> b = new B; 
}; 

deep_const_ptr cư xử như một con trỏ const T* const trong các phương pháp const A 's, và giống như T* trong các phương pháp không const. Fleshing lớp ra xa hơn là trái như là một bài tập cho người đọc.

Answer 2

Nếu bạn thay đổi thành viên của A từ

B* b; 

để

B b; 

sau đó bạn sẽ nhận được các hành vi mong đợi.

class A{ 
    public: 
     A() : b() {} 

     void changeMemberFromConstMethod() const{ 
      this->b.setVal(); // This will produce a compiler error. 
     } 
    private: 
     B b; 
} 

Answer 3

Vấn đề bạn có là một phương pháp const làm cho tất cả các biến thành viên const. Trong trường hợp này tuy nhiên, nó làm cho con trỏ const. Cụ thể, nó giống như tất cả những gì bạn có là B * const b, có nghĩa là một con trỏ liên tục đến một (vẫn) có thể thay đổi B. Nếu bạn không khai báo biến thành viên của bạn là const B * b, (nghĩa là, một con trỏ có thể thay đổi thành hằng số B), thì không có cách nào để bảo vệ khỏi hành vi này.

Nếu tất cả bạn cần là một const B, sau đó bằng mọi cách, xác định A như thế này:

class A { 
public: 
    A() : b(new B) {} 

    // This WILL give an error now. 
    void changeMemberFromConstMethod() const { b->setVal(); } 
private: 
    const B* b; 
} 

Tuy nhiên, nếu các phương pháp khác của A đột biến B, sau đó tất cả các bạn có thể làm là đảm bảo rằng B làm không bị đột biến trong các phương thức const của bạn là A.

Answer 4

Hãy thử sử dụng cách tiếp cận chung sau đây, để bảo vệ const-ness của các đối tượng được tham chiếu qua con trỏ, trong tình huống này.

1. Rename B * b

   B *my_pointer_to_b; 
   

   Và thay đổi khởi tạo trong constructor cho phù hợp.

2. Thực hiện hai cuống:

   B *my_b() { return b; } 
   const B *my_b() const { return b; } 
   

3. Thay thế tất cả tài liệu tham khảo hiện có để b với my_b(), trong các mã hiện có. Về sau, trong bất kỳ mã mới nào, luôn sử dụng hàm my_b() để trả về con trỏ đến b.

Phương pháp có thể thay đổi sẽ có con trỏ không đến B; Các phương thức const sẽ nhận được một con trỏ const tới B và bước bổ sung của việc đổi tên đảm bảo rằng tất cả các mã hiện có buộc phải tuân thủ chế độ mới.