以这种方式访问​​Base保护成员是否安全？

Question

I have two classes:

class base
{
protected:
   int x;
};

class der: public base
{
   void Acc(base& b)
   {
      b.*(&der::x) = 5;
   }
};

Is it safe to access a base protected member this way (&der::x) ? I'm worried that it could point to a wrong variable.

---

This is the way to pass by accessing protected member of a base class object.

The above code:

Answer 1

For those who might find difficult to understand the below line

b.*(&der::x) = 5;

It can be written as:

b.*(&(der::x)) = 5;

As scope resolution operator can be omitted as we have only one variable named x in base and derived class.

b.*(&x) = 5;

Which is nothing but taking address of x and then again dereferencing it. It can be written as:

b.x = 5;

Which I hope you might be aware of. But your code won't compile if you use bx instead of 'b.*(&der::x) = 5;' as 'x' is protected and this is used to bypass the compiler rule which prevents us from writing bx = 5;

Answer 2

是的，它是安全的 - 但它有点奇怪，并且会让读者感到困惑。

Answer 3

First of all don't make thing too complicated. When you compile this code it will never compile. I will tell you why this code is complicated and why it will not compile.

1> Why this code is complicated ?
According to the basic of c++ we can easily access the protected member of base 
class in drive class. So you can write you code like this.

class base { protected: int x; } // End of base class

class der: public base { void Acc() { x = 5; } }// End of der class.

 2> Why this code will not compile ?

*(&der::x) = 5;

This statement is correct and compile because it will put the value in x variable which is part of der class after the inheritance. In other word we can say that statement.

x = 5;

*(&der::x) = 5;

are equivalent and doing same thing, but if you write a statement like

b.(*(&der::x)) = 5;

It will generate error because when you use dot operator(.) to call the member of class then just after the (.) you have to specify the member of the class. So in above expression only x is the member of the class b except all will generate error.

Conclusion, if code will not compile then how we can say it is safe or not. Code is
safe or not is depend on the resource utilization, which it will during runtime.

Answer 4

What you are doing is an implicit cast, it is the same thing as writing static_cast<der&>(b).x = 5;

It is safe as long as you can be sure that the b argument is always of type der . What happens if you call it with some other type derived from base ? That type could use x for something else than der .

class nuclear_submarine: public base {};

void dostuff(der d)
{
   nuclear_submarine ns;
   d.Acc(ns); // *poff*
}

Answer 5

This syntax is a work around to compile the code without an error by bypassing the access rules of protected members. Before we start keep this in mind:
" In class X methods, we can access all its members ( private , protected , public ), irrespective of the member belongs to this object or other object of class X . "

Consider your function again:

void Acc(base& b)
{
  x = 5;  // ok, because `x` is a protected member to `this` object
  b.x = 5;  // error, because `b` isn't part of `this` object
}

Let's write the above code in little obfuscated way:

void Acc(base& b)
{
  this->(base::x) = 5;  // ok, because `x` is a protected member to `this` object
  b.(base::x) = 5;  // error, because `b` isn't part of `this` object
}

And still add one more level:

void Acc(base& b)
{
  this->*(&der::x) = 5;  // ok, because `x` is a protected member to `this` object
  b.*(&base::x) = 5;  // error, because `b` isn't part of `this` object
}

Now if you replace the 2nd statement by writing below statement:

b.*(&der::x) = 5;

It compiles fine !
In reality, it's equivalent to bx , but it bypasses the compiler rule which prevents us from writing bx = 5; .

But such kind of statement may often result in undefined behavior . Because, imagine what happens if the b is passed as a reference of some_other_derived_class_of_base ! The best bet is to introduce access methods for x in class base

void base::set_x (int v) { x = v; }