Making one of the inherited protected members private

Question

class A
{
protected:
    int m_a;
    int m_b;
};

class B: public A
{
};

In class B i want to make m_a private. Does the following the correct way to do it

class B:public A
{    
private:
    int m_a;
};

Won't this result in 2 copies of m_a ?

The answer to this question here may also help: http://stackoverflow.com/questions/2804880/in-c-what-is-the-scope-resolution-order-of-precedence-for-shadowed-variab — Tony The Lion, Sep 20 '12 at 10:46

score 5 · Answer 1 · edited May 23 '17 at 12:15

5

The correct way to adjust the access control of a member is with a using declaration:

class B: public A {    
private:
    using A::m_a;
}

Just writing int m_a; would indeed result in two copies of m_a, and a derived class would be able to access A's copy of m_a by writing A::m_a.

edited May 23 '17 at 12:15

Community

1
1

answered Sep 20 '12 at 10:46

ecatmur

152,476
27
293
366

However, deriving `class C` from `B`, you can still access `m_a` by explicitly qualifying it with `A::m_a`. – Alexander Tobias Bockstaller Sep 20 '12 at 10:47
3

@AlexanderTobiasHeinrich not with a conformant compiler; see e.g. http://liveworkspace.org/code/9ac3b1e42038bdd8cb5662fff0aa5753 – ecatmur Sep 20 '12 at 10:50
2

As the saying goes, "protect against Murphy, not Machiavelli". If a class client successfully circunvents the safeguard using `A::m_a` and things go awry, well, just deserts. – Gorpik Sep 20 '12 at 10:56
@CraigNelson C++11 isn't required here. Just a C++03 conformant compiler. – juanchopanza Sep 20 '12 at 11:16
No kidding. All this time.. those *were* the droids I was looking for. Thanks! – WhozCraig Sep 20 '12 at 11:54

juanchopanza · Accepted Answer · 2012-09-20T10:57:46.110

2

The m_a in class B shadows that of class A. It is a different data member, so class B actually has three ints: A::m_a, A::m_b and B::m_a. The way to get private access to m_a in B is to "use" A::m_a privately in class B:

class A {
  int m_a;
};

class B:  public A {    
    using A::m_a;
};

class C : public B {
  void foo() { 
    m_a++; // ERROR!
  }
};

edited Sep 20 '12 at 10:57

answered Sep 20 '12 at 10:43

juanchopanza

223,364
34
402
480

If that's the case, we would be getting redeclaration error is that right ? But I don't seem to get. – KodeWarrior Sep 20 '12 at 10:44
Not at all. but it does isolate m_a to B-code to be the one declared in B. The one in A is hidden from that point on unless class-resolved (A::m_a or ::m_a) – WhozCraig Sep 20 '12 at 10:46
No, it isn't a re-declaration: `A::m_a` and `B::m_a` are separate members in each instance of `B`. The name lookup rules may be confusing, though. – Useless Sep 20 '12 at 10:46
@KodeWarrior if you want to see name hiding in action, declare a function ``void foo()`` in ``class A``, then an ``int foo`` in ``class B``. – juanchopanza Sep 20 '12 at 11:14

score 0 · Answer 3 · answered Sep 20 '12 at 10:46

0

This code create three int storages in the class B.

The declaration of m_a creates a new variable - there is no redeclaration problem in c++ here as the declarations are in different scopes, more specifically A::m_a is not the same as B::m_a.

answered Sep 20 '12 at 10:46

Elemental

7,365
2
28
33

Making one of the inherited protected members private

3 Answers3