Предположим, что у класса есть личные члены данных, но сеттеры и получатели находятся в общедоступной области. Если вы наследуете этот класс, вы все равно можете вызвать эти сеттеры и геттеры - разрешить доступ к частным данным в базовом классе. Как это возможно, так как упоминается, что производный класс не может наследовать личные данные.Наследование частных членов в C++
Производный класс не наследует доступ к частным данным. Однако он наследует полный родительский объект, который содержит любые частные члены, которые объявляет этот класс.
Вы все еще можете манипулировать им, используя арифметику указателя – shreyasva
@ user265260: Возможно, но почему? Это поражает меня как проблему, которая просто ждет. Члены являются частными по какой-то причине, и если вы можете играть со своими значениями, вы можете испортить объект.Более того, если макет изменяется (и он может меняться между различными компиляторами, объект с членом 'size_t', вероятно, будет иметь разный макет с 32-битными и 64-битными компиляторами), вы топаете на совершенно разных данных. –
@ user265260: Это может работать на * вашей * платформе, но это никогда не требуется ** для работы. Когда-либо. –
Поскольку геттеры и сеттеры public - они могут быть вызваны кем угодно, а не только производными классами.
Мое сомнение в том, как вы можете манипулировать значениями частных членов данных, так как ясно, что вы не можете наследовать их – shreyasva
, и те геттеры и сеттеры являются членами базового класса, поэтому у них есть доступ к личным данным. – amertune
@ user235230: «Очевидно, вы не можете наследовать их». Это НЕПРАВИЛЬНО. –
Getters and setters не дают вам полный контроль над частными данными. Контроль по-прежнему лежит в базовом классе.
Использование шаблона
class MyClass {
private: int a;
public: void setA(int x) { a = x; }
public: int getA() const { return a; }
};
кажется объектно-ориентированным и посланное капсулирования.
Тем не менее,, как вы заметили, вы по-прежнему можете получить доступ к частному полю, и ничего не получилось, просто сделав публичное публичное объявление a и доступ к нему напрямую.
Использование геттеров и сеттеров, подобных этому, на самом деле не имеет смысла в C++.
На самом деле они это делают. В C# (например), если вы решили кэшировать доступ к 'a' здесь (при условии, что на самом деле было много работы для вычисления' a'), вы могли бы просто создать свойство, и вы бы это сделали. Тем не менее, в C++ вам придется пойти и заменить весь код, который ссылается на MyClass.a' с MyClass.GetA(); ' –
Этот вопрос связан с C++, а не с C#. И многие считают, что разумно предоставлять родовые геттеры и сеттеры для интегральных типов, но это не так. – Danvil
«Использование геттеров и сеттеров, подобных этому, на самом деле не имеет смысла в C++». Предоставление неограниченного доступа к элементам данных, кроме как через четко определенный интерфейс (например, геттеры и сеттеры), делает отслеживание ошибок кошмаром. Вам нужно посмотреть все места, где этот член настроен, чтобы попытаться определить, почему он имеет неожиданное значение. Ограничение доступа к членам класса через этот хорошо определенный интерфейс упрощает отладку, так как у вас есть трассировка стека, обеспечивающая некоторую полезную информацию. – andand
Это зависит от типа наследования. Если вы наследуете конфиденциально, то производный класс НЕ имеет доступа к частным членам Базы.
Access public protected private
-----------------------------------------------------------
members of the same class yes yes yes
members of derived classes yes yes no
not members yes no no
Я думаю, что этот ответ может ввести в заблуждение или хотя бы неточно. @JRL, пожалуйста, постарайтесь сделать его более понятным. – rineez
вы можете получить доступ к ним доступ к множеству сеттеров и добытчиками с общественностью и доступом к ним, как тот
*.h
class Mamifere{
private:
\t int a;
public:
\t Mamifere();
\t virtual ~Mamifere();
\t int getA();
\t // ~Mamifere(); //le delete dans le exp02() affiche seulement mamifere mort :(destructeur de la class mere
\t void manger() ;
\t virtual void avancer() const;
};
class Deufin:public Mamifere{
public:
\t Deufin();
\t void manger() const;
\t void avancer() const;
\t ~Deufin();
};
*.cpp
Mamifere::Mamifere(){
\t \t printf("nouveau mamifere est nee\n");
\t \t this->a=6;
\t }
Mamifere::~Mamifere(){
\t \t printf("mamifere Mort :(\n");
\t }
void Mamifere::manger() {
\t printf("hhhh je mange maifere %d\n",Mamifere::getA());
\t }
void Mamifere::avancer() const{
\t printf("allez-y Mamifere\n");
}
Deufin::Deufin(){
\t printf("nouveau Deufin est nee\n");
}
int Mamifere::getA(){
\t return this->a;
}
void Deufin::manger() const{
\t printf("hhhh je mange poisson\n");
\t
}
void Deufin::avancer() const{
\t
\t printf("allez-y Deufin\n");
}
Deufin::~Deufin(){
\t printf("Deufin Mort :(\n");
}
main.cpp
void exp031(){
\t Mamifere f;//nouveau mamifere est nee // nouveau Deufin est nee
\t Deufin d;
\t
\t f.avancer();//allez-y Deufin (resolution dynamique des lien la presence de mot cle virtual)
\t f.manger();//hhhh je mange maifere (resolution static des lien pas de mot cle virtual)
\t printf("a=%d\n",d.getA());//Deufin Mort :( mamifere Mort :((resolution static des lien la presence de mot cle virtual) distructeur de class fille appel auromatiquement le destructeur de la class mere
}
int main(){
\t exp031();
\t
\t getchar();
return 0;
}
Производный класс * делает * наследовать частные элементы данных. –
Что еще более запутанно, так это то, что вы можете переопределить частные виртуальные функции базового класса. –
@ Space_C0wb0y: Это совсем не смущает. Он называется шаблоном шаблона шаблона (который, к сожалению, не имеет ничего общего с шаблонами C++) –