thử nghiệm phức tạp để kiểm tra mà đối tượng khởi tạo một cuộc gọi chức năng

Question

Tôi có một struct (có thể là lớp) và được định nghĩa trong lớp khác như

struct A{ 
somedata_A; 
somespecificimplementation_A(someclass *S1); 
}; 

class someclass{ 
somedata_someclass; 
A a; 
}; 

main(){ 
someclass c1, *c2; 
c2 = &c1; 
c1.a.somespecificimplementation_A(c2); 
} 

Làm thế nào để xác minh c2 mà thực sự là một tài liệu tham khảo cho c1? Xin lỗi vì đã đưa ra ví dụ này vì rõ ràng c2 là tham chiếu cho c1.

Cập nhật: A không lưu trữ một con trỏ đến SomeClass

Answer 1

Nếu bạn không biết gì về cha mẹ, so sánh thành viên' adresses

void A::somespecificimplementation_A(someclass *S1) 
{ 
    if (this == &(S1->a)) { 
     // parent == S1 
    } else { 
     // parent != S1 
    } 
} 

Answer 2

Giả sử struct A có một con trỏ đến c1, sau đó bạn có thể mất một con trỏ đến c2 và so sánh giá trị con trỏ? Tương tự như những gì bạn sẽ làm với quá tải toán tử gán?

Answer 3

Giống như rằng:

struct A{ 
    int somedata_A; 
    int somespecificimplementation_A(someclass *S1){ 
    if ((void*) &(S1->a) == this) 
    { 
     std::cout << "S1 is a pointer to myself" << std::endl; 
     return 1; 
    } 
    return 0; 
    } 
}; 

Answer 4

Tại sao đi đường xung quanh và vượt qua một con trỏ của lớp học của bạn đến struct lồng nhau mà sau đó bạn phải kiểm tra, khi bạn thay vì có thể cung cấp một tài liệu tham khảo cho phụ huynh của phụ huynh trong quá trình xây dựng?

class someclass 
{ 
    public: 
     struct a 
     { 
      void foo() 
      { 
       parent.doSomething(); 
      } 

      private: 
       friend someclass; 
       a(someclass & parent) 
       : parent(parent) 
       {} 
       someclass & parent; 
     } a; 

     someclass() : a(*this) {} 

    private: 
     void doSomething() 
     { 
     } 
}; 

Answer 5

Mặc dù về mặt kỹ thuật không xác định, sau đây sẽ làm việc trên hiện đại nhất, máy mục đích chung:

void A::somespecificimplementation_A(someclass* S1) 
{ 
    char const* s = reinterpret_cast<char const*>(S1); 
    char const* t = reinterpret_cast<char const*>(this); 
    if (this >= s && this < s + sizeof(someclass)) { 
     // This A is a member of S1 
    } else { 
     // This A isn't 
    } 
} 

Có nói rằng, tôi sẽ nhấn mạnh:

1. Điều này là không được chỉ định theo tiêu chuẩn. Nó sẽ hoạt động trên các máy có địa chỉ bằng phẳng, tuyến tính, nhưng có thể không thành công (cung cấp các mặt tích cực sai) trên máy tính, ví dụ: bộ nhớ phân đoạn.

2. Tôi muốn đặt câu hỏi nghiêm túc về thiết kế nếu A cần biết ai là người là thành viên của.

3. Và nếu A thực sự cần thông tin này, nó thực sự cần lưu trữ con trỏ đến someclass, được chuyển cho hàm tạo của nó, sao cho phụ thuộc hiển thị.