When protected protects too much

Question

This is about "protected", which is explained as: "When a class inherits another one, the members of the derived class can access the protected members inherited from the base class." However, look at this code:

class Base {
public:
  Base( int m ) : member(m){}
protected:
  int member;
};

class Derived : public Base { // one of several subclasses
public:
  Derived( int m ) : Base(m), value(10) {}
  int diff( Base x ){
    return value - x.member;
  }
private:
  int value;
};

Derived accesses "x.member", which is protected in its Base class, right? But the compiler flags an error, "Base::member is protected". And, after mulling this over for a minute, I had to agree with the compiler.

And here comes the question: How do I make this work, with a minimum loss of information hiding?

Clearly, making "member" public compiles, but it's against the original intent.
Using the "friend" mechanism in Base to let subclasses access "member" (and everything else that's private and protected) is even worse (apart from the dumb binding of a superclass to its own subclasses - a maintenance nightmare).
In the simple example, a public int getMember(){ return member; } would be acceptable. But if member's type is a X*, the best you can do is a public const X* getMember(){...}.

Did I miss something?

Also when reading your point 1 and 3, one can conclude that the protection-of-member-sense is that it may be read but not changed. So a get method would do it well. Also a public const-reference or const-pointer-to-const to member, which is initialized in constructor list of Base would be possible. Your point 3 and "the best you can do ... const X*" depends on what you want: a get method returns value anyway. So you couldn't change the value of member of type X* with X* get(). Only what it points to. — mb84
What about making a function int diff(Derived d, Base b) and make this function a friend of both classes? — rozina
@mb84 diff used type Base in order to make it useful for all possible subtypes. (Perhaps Base* would make the intent clearer, but it's not polymorphism I'm after.) - My original situation had member's type as char*, and I disliked returning this pointer, even as a const char*. — laune
@rozina OK, if there aren't too many places where this kind of access is necessary. — laune

tmaric tmaric · Accepted Answer · 2014-02-08T09:40:53

You can keep the protected attributes, add the getter functions as you mentioned. As for a protected pointer attribute, the getter would make sure that int (or a const ref for a large object) is returned and you can do the difference in a function template that takes Derived and Base arguments then (getters give you the values for the calculation).

Protecting data attributes allows direct access to the protected attribute within the derived class. What you tried is to access a private attribute of another object. This part of your code:

int diff( Base x ){
    return value - x.member;
  }

would be equivalent to writing this in main:

Base x; 
cout << x.member << endl;

Here is an example of how to solve the problem using the option 3 you suggested yourself, with a derived class PointerDerived that is using pointers for the storage:

#include <iostream>

class Base {
public:
  Base( int m ) : member(m){}

  int getMember() const
  {
      return member; 
  }

protected:
  int member;
};

class Derived : public Base { // one of several subclasses
public:
  Derived( int m ) : Base(m), value(10) {}

  int getValue() const
  {
      std::cout << "protected = " << member << std::endl;
      return value; 
  }

private:
  int value;
};

class PointerDerived : public Base { // one of several subclasses
public:

  PointerDerived( int m ) : Base(m), value(new int (10)) {}

  int getValue() const
  {
      std::cout << "protected = " << member << std::endl;
      return *value; 
  }

  ~PointerDerived()
  {
      delete value; 
      value = nullptr;  
  }

private:
  int* value;
};

template<typename Derived, typename Base>
int diff(const Derived& d, const Base& b)
{
    return d.getValue() - b.getMember(); 
}

using namespace std;

int main(int argc, const char *argv[])
{
    PointerDerived p(23); 
    Base q(1);

    cout << diff(p, q) << endl; 

    return 0;
}

Compile the program with -std=c++11 because of the nullptr, or change it to NULL.

You make the diff a function template, so that you don't have to overload it for each and every derived class, and you let the derived class handle the storage and access to it as does for example PointerDerived.

When protected protects too much

2 Answers