Когда защита защищает слишком много

Question

Речь идет об «защищенном», что объясняется следующим образом: «Когда класс наследует другой, члены производного класса могут обращаться к защищенным членам, унаследованным от базового класса». Тем не менее, посмотрите на этот код:

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; 
}; 

Производная обращается «x.member», который защищен в его базовом классе, правильно? Но компилятор помещает ошибку, «Base :: member защищен». И, обдумав это на минуту, я должен был согласиться с компилятором.

И вот вопрос: Как это сделать, с минимальной потерей информации?

1. Очевидно, что создание «участника» публично компилируется, но оно против первоначального намерения.
2. Использование механизма «друга» в базе, чтобы подклассы могли получить доступ к «члену» (и все остальное, что является частным и защищенным) еще хуже (кроме немой привязки суперкласса к его собственным подклассам - кошмар обслуживания).
3. В простом примере public int getMember() {return member; } будет приемлемым. Но если тип участника - это X *, то лучше всего сделать это публично const X * getMember() {...}.

Я что-то пропустил?

Answer 1

Вы можете использовать статический защищенный аксессор:

class Base { 
public: 
    Base(int m) : member(m){} 
private: 
    int member; 
protected: 
    static int GetMember(const Base &b) 
    { return b.member; } 
}; 

class Derived : public Base { // one of several subclasses 
public: 
    Derived(int m) : Base(m), value(10) {} 
    int diff(Base &x){ //beware of your slicing! 
    return value - GetMember(x); 
    } 
private: 
    int value; 
}; 

Теперь позвольте мне добавить свою идею о том, почему C++ контроль доступа работает таким образом ...

контроля доступа в C++ скрывается не о информации.Это около инкапсуляция. То есть, прямо говоря, вы отфильтровываете доступ к любому члену, который может сломать класс, если он используется неправильно.

В идеальном классе

• общественные члены не могут быть использованы, чтобы сломать объект.
• Частные члены знают, что они делают.

Как вы видите, в моей схеме есть небольшое место для защищенных членов:

• защищенных элементов используются для реализации интерфейса наследования, если таковые имеются.

И даже меньшее место для защищенных переменных-членов.

Так что сделайте вашу переменную приватной и напишите защищенный аксессуар. Аксессор должен быть статичным, чтобы его можно было использовать из производного объекта.

Answer 2

Вы можете сохранить защищенные атрибуты, добавить функции геттера, как вы упомянули. Что касается атрибута защищенного указателя, то getter должен удостовериться, что int (или const ref для большого объекта) возвращается, и вы можете сделать разницу в шаблоне функции, который принимает аргументы Derived и Base тогда (getters дают вам значения для расчет).

Защита атрибутов данных обеспечивает прямой доступ к защищенному атрибуту в производном классе. Вы пытались получить доступ к частному атрибуту другого объекта. Эта часть кода:

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

будет эквивалентно написанию этого в main:

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

Вот пример того, как решить эту проблему с помощью опции 3 вы предложили себя, с производным класс PointerDerived, который использует указатели для хранения:

#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; 
} 

Компиляция программы с -std=c++11 из-за nullptr или изменения до NULL.

Вы создаете шаблон функции diff, поэтому вам не нужно перегружать его для каждого производного класса, и вы позволяете производному классу обрабатывать хранилище и доступ к нему, например, PointerDerived.