Принятие наследства не допускается: Статья 1152 ГК РФ. Принятие наследства

Почему множественное наследование невозможно в C#?

C# поддерживает , а не множественное наследование , потому что они рассудили, что добавление множественного наследования слишком усложняет C#, но дает слишком мало преимуществ. В C# только классам разрешено от до наследовать от одного родительского класса, что называется одиночным наследованием .

Нажмите, чтобы увидеть полный ответ.

Люди также спрашивают, почему множественное наследование не разрешено?

Java поддерживает множественное наследование только через интерфейсы. Класс может реализовывать любое количество интерфейсов, но может расширять только один класс. Множественное наследование не поддерживается , так как это приводит к смертельной проблеме с алмазами. Интерфейс — это контракт вещей, которые должен реализовать ваш класс.

Также знаете, можем ли мы наследовать несколько интерфейсов в C#? Интерфейсы подобны соглашениям или «контрактам» о том, что может делать класс .Классы могут иметь несколько интерфейсов , но классы не могут наследовать несколько классов . Классы , наследующие от более чем , один класс известен как множественное наследование — . C# не разрешает множественное — наследование .

Кроме того, что такое проблема Diamond в множественном наследовании C#?

«Проблема алмаза » — это двусмысленность, возникающая, когда два класса B и C наследуют от A, а класс D наследует от B и C. Если в A есть метод, который B и C переопределили, а D не переопределяет его, то какой класс метода D наследует : класс B или класс C?

Что такое множественное наследование в C# с примером?

C# не позволяет множественное наследование с классами, но его можно реализовать с помощью интерфейса. Причина в следующем: Множественное наследование добавляет слишком много сложности с небольшой выгодой. Есть огромные шансы конфликтующего члена базового класса. Наследование с интерфейсом обеспечивает ту же работу, что и множественное наследование .

Основы наследования — Visual Basic

• Статья
• 15.09.2021
• 6 минут на чтение

Пожалуйста, оцените свой опыт

да Нет

Любая дополнительная обратная связь?

Отзыв будет отправлен в Microsoft: при нажатии кнопки отправки ваш отзыв будет использован для улучшения продуктов и услуг Microsoft. Политика конфиденциальности.

Представлять на рассмотрение

Спасибо.

В этой статье

Оператор Inherits используется для объявления нового класса, называемого производным классом , на основе существующего класса, известного как базовый класс . Производные классы наследуют и могут расширять свойства, методы, события, поля и константы, определенные в базовом классе.В следующем разделе описаны некоторые правила наследования и модификаторы, которые можно использовать для изменения способа наследования или наследования классов:

• По умолчанию все классы наследуются, если они не отмечены ключевым словом NotInheritable . Классы могут наследоваться от других классов в вашем проекте или от классов в других сборках, на которые ссылается ваш проект.

• В отличие от языков, допускающих множественное наследование, Visual Basic допускает только одиночное наследование в классах; то есть производные классы могут иметь только один базовый класс. Хотя множественное наследование в классах не допускается, классы могут реализовывать несколько интерфейсов, которые могут эффективно выполнять одни и те же задачи.

• Чтобы предотвратить предоставление ограниченных элементов в базовом классе, тип доступа производного класса должен быть равен или более ограничивающим, чем его базовый класс. Например, класс Public не может наследовать класс Friend или класс Private , а класс Friend не может наследовать класс Private .

Модификаторы наследования

В Visual Basic представлены следующие операторы и модификаторы уровня класса для поддержки наследования:

• Наследует оператор — определяет базовый класс.

• Модификатор NotInheritable — запрещает программистам использовать класс в качестве базового класса.

• Модификатор MustInherit — Указывает, что класс предназначен для использования только в качестве базового класса. Экземпляры классов MustInherit нельзя создавать напрямую; они могут быть созданы только как экземпляры базового класса производного класса. (Другие языки программирования, такие как C++ и C#, используют термин абстрактный класс для описания такого класса.)

Переопределение свойств и методов в производных классах

По умолчанию производный класс наследует свойства и методы своего базового класса. Если унаследованное свойство или метод должны вести себя иначе в производном классе, они могут быть переопределены .То есть вы можете определить новую реализацию метода в производном классе. Следующие модификаторы используются для управления переопределением свойств и методов:

• Переопределяемый — позволяет переопределять свойство или метод класса в производном классе.

• Переопределение — переопределение свойства или метода Overridable , определенного в базовом классе.

• NotOverridable — Предотвращает переопределение свойства или метода в наследующем классе.По умолчанию методы Public имеют значение NotOverridable .

• MustOverride — Требуется, чтобы производный класс переопределял свойство или метод. Когда используется ключевое слово MustOverride , определение метода состоит только из оператора Sub , Function или Property . Никакие другие операторы не допускаются, в частности, нет оператора End Sub или End Function . Методы MustOverride должны быть объявлены в классах MustInherit .

Предположим, вы хотите определить классы для расчета заработной платы. Вы можете определить общий класс Payroll , который содержит метод RunPayroll , вычисляющий заработную плату за обычную неделю. Затем вы можете использовать Payroll в качестве базового класса для более специализированного класса BonusPayroll , который можно использовать при распределении бонусов сотрудников.

Класс BonusPayroll может наследовать и переопределять метод PayEmployee , определенный в базовом классе Payroll .

В следующем примере определяется базовый класс Payroll, и производный класс BonusPayroll , который переопределяет унаследованный метод PayEmployee . Процедура RunPayroll создает и затем передает объект Payroll и объект BonusPayroll функции Pay , которая выполняет метод PayEmployee обоих объектов.

  Const BonusRate в десятичном виде = 1,45D
Const PayRate As Decimal = 14.75Д

Заработная плата класса
    Переопределяемая функция PayEmployee(
        ByVal HoursWorked как Decimal,
        ByVal PayRate как десятичный) как десятичный

        PayEmployee = Отработанные часы * Ставка заработной платы
    Конечная функция
Конец класса

Класс БонусЗарплата
    Наследует платежную ведомость
    Переопределяет функцию PayEmployee(
        ByVal HoursWorked как Decimal,
        ByVal PayRate как десятичный) как десятичный

        ' Следующий код вызывает исходный метод в базе
        ', а затем изменяет возвращаемое значение. 
        PayEmployee = Моя база.PayEmployee(HoursWorked, PayRate) * BonusRate
    Конечная функция
Конец класса

Sub RunPayroll ()
    Dim PayrollItem As Payroll = New Payroll
    Dim BonusPayrollItem As New BonusPayroll
    Тусклые часы работы в десятичном виде = 40

    MsgBox("Обычная оплата: " &
        PayrollItem.PayEmployee(HoursWorked, PayRate))
    MsgBox("Оплатить бонусом: " &
        BonusPayrollItem.PayEmployee(HoursWorked, PayRate))
Конец сабвуфера
  

Ключевое слово MyBase

Ключевое слово MyBase ведет себя как объектная переменная, ссылающаяся на базовый класс текущего экземпляра класса. MyBase часто используется для доступа к членам базового класса, которые переопределены или затенены в производном классе. В частности, MyBase.New используется для явного вызова конструктора базового класса из конструктора производного класса.

Например, предположим, что вы разрабатываете производный класс, который переопределяет метод, унаследованный от базового класса. Переопределенный метод может вызвать метод базового класса и изменить возвращаемое значение, как показано в следующем фрагменте кода:

  Класс Производный класс
    Наследует базовый класс
    Публичные переопределения функции CalculateShipping(
        ByVal Dist As Double,
        ByVal Ставка в двойном размере) В двойном размере

        ' Вызовите метод в базовом классе и измените возвращаемое значение.Вернуть MyBase.CalculateShipping(Расстояние, Скорость) * 2
    Конечная функция
Конец класса
  

В следующем списке описаны ограничения на использование MyBase :

• MyBase относится к непосредственному базовому классу и его унаследованным членам. Его нельзя использовать для доступа к закрытым членам класса.

• MyBase — это ключевое слово, а не реальный объект. MyBase нельзя присвоить переменной, передать в процедуры или использовать в сравнении Is .

• Метод, квалифицируемый MyBase , не обязательно должен быть определен в непосредственном базовом классе; вместо этого он может быть определен в косвенно унаследованном базовом классе. Для правильной компиляции ссылки, квалифицированной MyBase , некоторый базовый класс должен содержать метод, соответствующий имени и типам параметров, которые появляются в вызове.

• Вы не можете использовать MyBase для вызова методов базового класса MustOverride .

• MyBase нельзя использовать для самоопределения. Поэтому следующий код недействителен:

  MyBase.MyBase.BtnOK_Click()

• MyBase нельзя использовать в модулях.

• MyBase нельзя использовать для доступа к членам базового класса, помеченным как Friend , если базовый класс находится в другой сборке.

Дополнительные сведения и другой пример см. в разделе Практическое руководство. Доступ к переменной, скрытой производным классом.

Ключевое слово MyClass

Ключевое слово MyClass ведет себя как объектная переменная, которая ссылается на текущий экземпляр класса, реализованный изначально. MyClass похож на Me , но каждый вызов метода и свойства в MyClass обрабатывается так, как если бы метод или свойство были NotOverridable. Поэтому на метод или свойство не влияет переопределение в производном классе.

• MyClass — это ключевое слово, а не реальный объект. MyClass нельзя присвоить переменной, передать в процедуры или использовать в сравнении Is .

• MyClass относится к содержащему классу и его унаследованным членам.

• MyClass можно использовать в качестве квалификатора для Shared членов.

• MyClass нельзя использовать внутри метода Shared , но его можно использовать внутри метода экземпляра для доступа к общему члену класса.

• MyClass нельзя использовать в стандартных модулях.

• MyClass можно использовать для определения метода, определенного в базовом классе и не имеющего реализации метода, предоставленного в этом классе. Такая ссылка имеет то же значение, что и MyBase. Метод .

В следующем примере сравниваются Me и MyClass .

  Класс базовый класс
    Публичный переопределяемый Sub testMethod()
        MsgBox("Строка базового класса")
    Конец сабвуфера
    Публичная подпрограмма useMe()
        ' Следующий вызов использует метод вызывающего класса, даже если
        ' этот метод является переопределением.Me.testMethod()
    Конец сабвуфера
    Общедоступный подпункт useMyClass()
        ' Следующий вызов использует метод этого экземпляра, а не какой-либо
        'переопределить.
        MyClass.testMethod()
    Конец сабвуфера
Конец класса
Класс производный класс: наследует базовый класс
    Публичные переопределения Sub testMethod()
        MsgBox("Строка производного класса")
    Конец сабвуфера
Конец класса
Тестовые классы
    ПодзаголовокЗдесь()
        Dim testObj Как производный класс = новый производный класс ()
        ' Следующий вызов отображает "строку производного класса". 
        testObj.использовать меня()
        ' Следующий вызов отображает "строку базового класса".
        testObj.useMyClass()
    Конец сабвуфера
Конец класса
  

Несмотря на то, что производный класс переопределяет testMethod , ключевое слово MyClass в useMyClass сводит на нет последствия переопределения, и компилятор разрешает вызов версии базового класса testMethod .

См. также

Наследие — это зло. Прекратите его использовать. | Николо Пигнателли

Используете ли вы наследование в своем коде? Немедленно остановись. Ты только себе вредишь.

Я знаю, это не то, чему все учили десятилетиями. Использование наследования для поведенческой композиции и полиморфизма — это распространенная часть знаний, которую вы найдете в каждой книге или блоге по ООП 101.

К сожалению, это неправильно .

Использование наследования — не единственный способ расширить поведение класса, но определенно самый опасный и вредный .

Серьезно?

Да.

Представьте, что вы пишете класс с несколькими методами и свойствами.Теперь представьте, что вы или кто-то другой расширяете этот класс. Вы понимаете, что только что произошло, делая это?

Связь была создана между двумя классами бетона.

Одно изменение в базовом классе может повлиять на поведение потомка.

Но это нормально — можно сказать — Я справлюсь .

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

Что происходит, когда вам приходится изменять поведение базового класса или другого класса в середине дерева наследования? Вы достаточно уверены, что ничего не сломаете?

Сложно, не правда ли?

Как насчет тестирования каждого класса? Как вы думаете, вы можете сделать это, не привлекая ничего, кроме тестируемой системы? Я так не думаю.

Ну, позвольте мне сказать вам одну вещь: именно так рождаются плохие монолиты . Один наследуемый класс за другим.

Использование наследования — не единственный способ расширить поведение класса. Но однозначно самый опасный и вредный.

Конечно есть.

Речь идет об овладении точной философией проектирования, благодаря которой автоматически избегает сложностей, связанных с наследованием .

Верьте или нет, Я не использую наследование в 99% своего кода . И я действительно имею в виду 99%.

Как мне получить этот номер, спросите вы? Я применяю следующие правила к своему коду:

• Я использую только два типа объявлений уровня класса: интерфейсы и конечные классы ;
• Я внедряю интерфейсы в конструкторы зависимых классов;
• I не позволять внедрять любую зависимость класса, кроме интерфейсов;
• Я использую контейнер внедрения зависимостей (или эквивалентный метод, в зависимости от того, на каком языке я пишу код) для управления созданием своих экземпляров;
• Если я чувствую, что добавляю слишком много зависимостей в класс, я переосмысливаю свой дизайн с точки зрения обязанностей класса и использования принципа разделения интерфейса;
• При необходимости я разделяю сложное поведение на несколько конечных классов, реализующих один и тот же интерфейс;
• Я использую только наследование и имею в виду только , когда это имеет смысл на семантическом уровне и только в целях расширения, без какого-либо изменения базового поведения;
• Я позволяю себе нарушать предыдущие правила только в 1% моего кода.

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

Дайте себе несколько дней на то, чтобы привыкнуть к новому стилю кодирования, потому что магия случается только тогда, когда вы лучше освоитесь. И вот что вы начнете видеть в своей кодовой базе:

• четкие контракты ; использование интерфейсов заставит вас думать о связи между объектами;
• мышление «сначала общение» даст вашему мозгу бесплатные ресурсы за счет разделения работы на два этапа: время разработки и время реализации; наш мозг не любит работать над двумя разными вещами одновременно, особенно постоянно переключаясь между ними;
• изолированные кодовые блоки без побочных эффектов ; внедрение интерфейсов только как зависимостей удалит все неприятные побочные эффекты кода, над которым вы работаете; изменение реализации интерфейса не повлияет на другие конкретные классы, так как они зависят только от абстракции интерфейса;
• тестируемость ; имитировать зависимости чрезвычайно просто, когда они являются интерфейсами; больше никаких проблем типа «Я забыл отключить конструктор / имитировать этот конкретный метод» в вашей тестируемой системе;
• низкая, управляемая сложность ; поскольку все изолировано, вам не нужно беспокоиться о скачкообразных изменениях; это значительно снижает сложность вашего кода;
• низкая когнитивная нагрузка ; с уменьшенной сложностью ваш мозг сможет сосредоточиться на том, что важно;
• код текучести ; убрав все ненужные связи, вы сможете перемещать вещи намного легче, чем раньше;
• уверенность в себе ; возможность так хорошо тестировать свой код изолированно даст вам прекрасное чувство уверенности в его изменении; больше никаких часов ручного щелкания по тестированию, скрещенных пальцев релизов и горячих исправлений в пятницу днем.

Вам следует прекратить использование наследования прямо сейчас. Вам это не нужно. Вы не хотите, чтобы это было в вашей кодовой базе.

Что вы должны начать делать вместо этого:

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

Ваша кодовая база будет вам благодарна.

Ваш менеджер поблагодарит вас (на самом деле она, скорее всего, скажет « вау, вы так быстро сделали! И никаких багов не появилось! »).

Члены вашей команды будут вам благодарны.

И ты в будущем тоже скажешь тебе спасибо.

Почему множественное наследование не поддерживается в Java?

Множественное наследование не поддерживается в java через класс, чтобы предотвратить ситуации, возникающие из-за неоднозначности.

Давайте поймем то же самое на примере.

Предположим, что два класса, которые унаследованы любым третьим классом (или дочерним классом), имеют метод с тем же именем.

Если этот метод вызывается из дочернего класса, то в этом случае неясно, какой метод классов следует вызывать. Таким образом, создается двусмысленный сценарий.

Например, рассмотрим ниже изображение множественного наследования, приведенное ниже.

Предположим, что class Science и class Commerce имеют метод formFillUp().

Класс приема наследует как класс Наука, так и класс Коммерция.

Теперь, если мы попытаемся вызвать или использовать метод formFillUp() из класса Admission, у нас возникнет вопрос.

Какой метод класса formFillUp() вызывается?

Поскольку по свойству наследования класс Admission имеет доступ к методу обоих классов, ему будет сложно решить, какой из них вызывать.

Это неоднозначность , которую мы до сих пор указывали на .

Чтобы уменьшить вероятность возникновения таких ситуаций, Java не поддерживает множественное наследование.

Таким образом, Java не поддерживает множественное наследование через класс.

Однако мы можем реализовать множественное наследование , используя концепцию интерфейса Java .

Об авторе

Сону Пандит
Я главный редактор tutorialsinhand. com отвечает за управление, просмотр и отправку статей/контента для окончательного утверждения для публикации. Свяжитесь со мной@https://www.linkedin.com/in/sonu-pandit-a77b471ab/. Присоединяйтесь к программе write4us и поделитесь своим мастерством

Просмотров страниц : Дата публикации : 12 июля 2020 г.  

17.5 — Наследование и спецификаторы доступа — Изучите C++

В предыдущих уроках этой главы вы немного узнали о том, как работает базовое наследование. Во всех наших примерах до сих пор мы использовали открытое наследование. То есть наш производный класс публично наследует базовый класс.

В этом уроке мы более подробно рассмотрим публичное наследование, а также два других вида наследования (частное и защищенное). Мы также рассмотрим, как различные виды наследования взаимодействуют со спецификаторами доступа, чтобы разрешить или ограничить доступ к членам.

К этому моменту вы познакомились с спецификаторами доступа private и public, которые определяют, кто может получить доступ к членам класса. Напомню, что доступ к публичным членам может получить кто угодно. К закрытым членам могут обращаться только функции-члены того же класса или друзья. Это означает, что производные классы не могут напрямую обращаться к закрытым членам базового класса!

  класс Базовый
{
частный:
    интервал m_private {}; // доступ возможен только для членов Base и друзей (не производных классов)
публичный:
    интервал m_public {}; // может получить доступ любой
};  

Это довольно просто, и вы уже должны к этому привыкнуть.

Спецификатор защищенного доступа

При работе с унаследованными классами все становится немного сложнее.

C++ имеет третий спецификатор доступа, о котором нам еще предстоит поговорить, поскольку он полезен только в контексте наследования. Спецификатор доступа protected позволяет классу, к которому принадлежит член, друзьям и производным классам получать доступ к члену. Однако защищенные члены недоступны извне класса.

  класс Базовый
{
публичный:
    интервал m_public {}; // может получить доступ любой
защищено:
    интервал m_protected {}; // могут быть доступны члены Base, друзья и производные классы
частный:
    интервал m_private {}; // доступ возможен только для членов Base и друзей (но не для производных классов)
};

Производный класс: общедоступная база
{
публичный:
    Полученный()
    {
        m_public = 1; // разрешено: можно получить доступ к общедоступным базовым членам из производного класса
        м_защита = 2; // разрешено: можно получить доступ к защищенным базовым членам из производного класса
        м_частное = 3; // не разрешено: нельзя получить доступ к закрытым базовым членам из производного класса
    }
};

основной ()
{
    Базовая база;
    база. m_public = 1; // разрешено: можно получить доступ к публичным членам из внешнего класса
    base.m_protected = 2; // не разрешено: нельзя получить доступ к защищенным членам из внешнего класса
    base.m_private = 3; // не разрешено: нельзя получить доступ к закрытым членам из внешнего класса

    вернуть 0;
}  

В приведенном выше примере видно, что защищенный базовый член m_protected напрямую доступен производному классу, но не общедоступному.

Итак, когда следует использовать спецификатор защищенного доступа?

При наличии защищенного атрибута в базовом классе производные классы могут напрямую обращаться к этому члену.Это означает, что если вы позже что-либо измените в этом защищенном атрибуте (тип, значение значения и т. д.), вам, вероятно, потребуется изменить как базовый класс, так и все производные классы.

Таким образом, использование спецификатора защищенного доступа наиболее полезно, когда вы (или ваша команда) собираетесь быть производными от ваших собственных классов, а количество производных классов является разумным. Таким образом, если вы вносите изменения в реализацию базового класса, и в результате необходимы обновления производных классов, вы можете сделать обновления самостоятельно (и это не займет вечность, поскольку количество производных классов ограничено). ).

Создание закрытых членов означает, что общедоступные и производные классы не могут напрямую вносить изменения в базовый класс. Это хорошо для изоляции общедоступных или производных классов от изменений реализации и для обеспечения правильного обслуживания инвариантов. Однако это также означает, что вашему классу может потребоваться более крупный общедоступный (или защищенный) интерфейс для поддержки всех функций, необходимых общедоступным или производным классам для работы, создание, тестирование и обслуживание которых требует определенных затрат.

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

Передовая практика

Предпочтение закрытым членам защищенным членам.

Различные виды наследования и их влияние на доступ

Во-первых, классы могут наследовать от других классов тремя разными способами: открытым, защищенным и закрытым.

Для этого просто укажите, какой тип доступа вы хотите при выборе класса для наследования:

  // Публично наследовать от Base
класс Pub: общедоступная база
{
};

// Защищенное наследование от Base
класс Pro: защищенная база
{
};

// Наследовать от базы приватно
класс Pri: частная база
{
};

class Def: Base // По умолчанию используется частное наследование
{
};  

Если вы не выберете тип наследования, C++ по умолчанию использует частное наследование (точно так же, как члены по умолчанию имеют частный доступ, если не указано иное).

Это дает нам 9 комбинаций: 3 спецификатора доступа к элементам (общедоступный, частный и защищенный) и 3 типа наследования (общедоступный, частный и защищенный).

Так в чем между ними разница? Короче говоря, когда члены наследуются, спецификатор доступа для унаследованного члена может быть изменен (только в производном классе) в зависимости от используемого типа наследования. Иными словами, члены, которые были общедоступными или защищенными в базовом классе, могут изменить спецификаторы доступа в производном классе.

Это может показаться немного запутанным, но это не так уж и плохо. Мы посвятим оставшуюся часть этого урока подробному изучению этого.

При рассмотрении примеров помните о следующих правилах:

• Класс всегда может обращаться к своим (не унаследованным) членам.
• Публичный доступ к членам класса на основе спецификаторов доступа класса, к которому он обращается.
• Производный класс обращается к унаследованным членам на основе спецификатора доступа, унаследованного от родительского класса.Это зависит от спецификатора доступа и типа используемого наследования.

Открытое наследование

Открытое наследование является наиболее часто используемым типом наследования. На самом деле, вы очень редко увидите или будете использовать другие типы наследования, поэтому основное внимание следует уделить пониманию этого раздела. К счастью, публичное наследование проще всего понять. Когда вы публично наследуете базовый класс, унаследованные открытые члены остаются открытыми, а унаследованные защищенные члены остаются защищенными.Унаследованные частные члены, которые были недоступны, потому что они были закрытыми в базовом классе, остаются недоступными.

Вот пример показывает как все работает:

  класс Base
{
публичный:
    интервал m_public {};
защищено:
    интервал m_protected {};
частный:
    интервал m_private {};
};

class Pub: public Base // примечание: публичное наследование
{
    // Публичное наследование означает:
    // Публичные унаследованные члены остаются общедоступными (поэтому m_public считается общедоступным)
    // Защищенные унаследованные члены остаются защищенными (поэтому m_protected считается защищенным)
    // Частные унаследованные члены остаются недоступными (поэтому m_private недоступен)
публичный:
    Паб()
    {
        m_public = 1; // хорошо: m_public был унаследован как public
        м_защита = 2; // хорошо: m_protected был унаследован как защищенный
        м_частное = 3; // не в порядке: m_private недоступен из производного класса
    }
};

основной ()
{
    // Внешний доступ использует спецификаторы доступа класса, к которому осуществляется доступ. Базовая база;
    base.m_public = 1; // хорошо: m_public общедоступен в Base
    base.m_protected = 2; // не в порядке: m_protected защищен в базе
    base.m_private = 3; // не в порядке: m_private является приватным в базе

    паб-паб;
    pub.m_public = 1; // хорошо: m_public общедоступен в Pub
    pub.m_protected = 2; // не в порядке: m_protected защищен в Pub
    pub.m_private = 3; // не в порядке: m_private недоступен в Pub

    вернуть 0;
}  

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

Публичное наследование — это то, что вы должны использовать, если у вас нет особых причин не делать этого.

Передовая практика

Используйте открытое наследование, если у вас нет особой причины поступать иначе.

Защищенное наследование

Защищенное наследование — наименее распространенный метод наследования. Он почти никогда не используется, за исключением очень особых случаев. При защищенном наследовании открытые и защищенные члены становятся защищенными, а частные члены остаются недоступными.

Поскольку эта форма наследования встречается очень редко, мы пропустим этот пример и просто суммируем в таблице:

Частный наследование

При наследовании класса private все члены наследуются от базового частного класса.Это означает, что частные члены остаются частными, а защищенные и общедоступные члены становятся частными.

Обратите внимание, что это не влияет на то, как производный класс обращается к членам, унаследованным от его родителя! Это влияет только на код, пытающийся получить доступ к этим членам через производный класс.

  класс Базовый
{
публичный:
    интервал m_public {};
защищено:
    интервал m_protected {};
частный:
    интервал m_private {};
};

class Pri: private Base // примечание: private наследование
{
    // Частное наследование означает:
    // Публичные унаследованные члены становятся приватными (поэтому m_public считается приватным)
    // Защищенные унаследованные члены становятся закрытыми (поэтому m_protected считается закрытым)
    // Частные унаследованные члены остаются недоступными (поэтому m_private недоступен)
публичный:
    При ()
    {
        m_public = 1; // хорошо: m_public теперь приватный в Pri
        м_защита = 2; // хорошо: m_protected теперь приватный в Pri
        м_частное = 3; // не в порядке: производные классы не могут получить доступ к закрытым членам в базовом классе
    }
};

основной ()
{
    // Внешний доступ использует спецификаторы доступа класса, к которому осуществляется доступ.// В этом случае спецификаторы доступа base.
    Базовая база;
    base. m_public = 1; // хорошо: m_public общедоступен в Base
    base.m_protected = 2; // не в порядке: m_protected защищен в базе
    base.m_private = 3; // не в порядке: m_private является приватным в базе

    При при;
    pri.m_public = 1; // не в порядке: m_public теперь приватный в Pri
    pri.m_protected = 2; // не в порядке: m_protected теперь приватный в Pri
    pri.m_private = 3; // не в порядке: m_private недоступен в Pri

    вернуть 0;
}  

Для суммирования в таблице Форма:

Частное наследование может быть полезно, когда производный класс не имеет очевидных отношений с базовым классом, но использует базовый класс для внутренней реализации.В таком случае мы, вероятно, не хотим, чтобы открытый интерфейс базового класса открывался через объекты производного класса (как это было бы, если бы мы наследовали открыто).

На практике частное наследование используется редко.

Последний пример

  класс Базовый
{
публичный:
интервал m_public {};
защищено:
интервал m_protected {};
частный:
интервал m_private {};
};  

База имеет доступ к своим членам без ограничений. Публика может получить доступ только к m_public. Производные классы могут обращаться к m_public и m_protected.

  класс D2: частная база // примечание: частное наследование
{
// Частное наследование означает:
// Публичные унаследованные члены становятся приватными
// Защищенные унаследованные члены становятся закрытыми
// Частные унаследованные члены остаются недоступными
публичный:
интервал m_public2 {};
защищено:
интервал m_protected2 {};
частный:
интервал m_private2 {};
};  

D2 имеет доступ к своим членам без ограничений. D2 может получить доступ к членам Base m_public и m_protected, но не к m_private. Поскольку D2 унаследовал Base частным образом, m_public и m_protected теперь считаются частными при доступе через D2. Это означает, что публика не может получить доступ к этим переменным при использовании объекта D2, равно как и никакие классы, производные от D2.

  класс D3: общедоступный D2
{
// Публичное наследование означает:
// Публичные унаследованные члены остаются открытыми
// Защищенные унаследованные члены остаются защищенными
// Частные унаследованные члены остаются недоступными
публичный:
интервал m_public3 {};
защищено:
интервал m_protected3 {};
частный:
интервал m_private3 {};
};  

D3 может обращаться к своим членам без ограничений. D3 может получить доступ к членам m_public2 и m_protected2 D2, но не к m_private2.Поскольку D3 публично унаследовал D2, m_public2 и m_protected2 сохраняют свои спецификаторы доступа при доступе через D3. D3 не имеет доступа к базе m_private, которая уже была приватной в Base. У него также нет доступа к базам m_protected или m_public, которые стали закрытыми, когда D2 унаследовал их.

Сводка

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

Во-первых, класс (и друзья) всегда может получить доступ к своим ненаследственным членам.Спецификаторы доступа влияют только на то, могут ли посторонние и производные классы обращаться к этим членам.

Во-вторых, когда производные классы наследуют члены, эти члены могут изменить спецификаторы доступа в производном классе. Это не влияет на собственные (не унаследованные) члены производных классов (которые имеют свои собственные спецификаторы доступа). Это влияет только на то, могут ли посторонние лица и классы, производные от производного класса, получить доступ к этим унаследованным членам.

Вот стол всех видов спецификатора доступа и типы наследования Комбинации:

в заключительной ноте, хотя в приведенных выше примерах мы показали только примеры с использованием переменных-членов, эти правила доступа верны для всех членов (например,г.