Конструктор чем полезен для детей


Как конструкторы Лего способствуют развитию детей?

Мы все с детства знакомы с конструкторами: разные материалы, цвета и размеры позволяли нам создавать целые вселенные и могли увлечь на целый день. Современные родители уже застали эпоху Лего будучи детьми и помнят, как новый набор был самым желанным подарком, а от процесса конструирования ничего не могло отвлечь. Современные дети также легко увлекаются созданием моделей из Лего, а новые наборы предлагают гораздо более широкие возможности для творчества. Давайте же разбираться, есть ли польза конструкторов для развития малышей на примере самого популярного из них – конструктора Лего.

Процесс игры в конструктор

Следует отметить, что любой конструктор – это в первую очередь инструмент. И, как любой инструмент, он может использоваться по-разному. Если проанализировать способы игры в Лего, то можно выделить следующие:

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

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

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

В чем польза конструкторов Лего для ребенка?

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

Лего способствует развитию мелкой моторики

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

Лего развивает креативность и нестандартное мышление

Придумывая собственные модели, дети учатся сочетать детали разных форм, цветов и размеров. Играя в Лего самостоятельно, малыши могут создавать самые разные модели, начиная от домика фермера, заканчивая инопланетным космическим кораблём. При этом у детей почти нет ограничений по виду и конструкции моделей, а значит и нет страха сделать что-то неправильно. Именно эти условия и создают атмосферу для развития воображения и креативности.

Лего развивает внимание, умение планировать и решать проблемы

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

Лего развивает пространственное и логическое мышление

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

Лего способствует развитию речи ребенка

Играя в конструктор в компании сверстников или взрослого, ребенок учится объяснять свои идеи, описывать процесс конструирования и затруднения, которые встретились на пути. Словарный запас ребенка пополняется за счет обсуждения моделей: например, малыш обнаруживает, что спереди у машины есть капот, место, куда заливают бензин, называется топливный бак, а вещи водитель может складывать в багажник. Используя разные сюжеты и сильное желание поделиться своими идеями, ребенок, сам того не замечая, начинает использовать всё больше и больше новых слов и выражений.

Лего развивает умение работать в команде

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

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

Лего развивает целеустремленность и укрепляет самооценку ребенка

Играя в Лего, дети склонны строить всё более и более сложные конструкции. Такие модели требуют не только развитых навыков планирования, но целеустремленности для достижения цели. Встречаясь с трудностями, ребенок может перестроить модель чуть ли не с нуля, но и награда в виде результата не заставит себя ждать. Конструктор Лего разработан таким образом, что внешние факторы почти не влияют на конечный результат - детали крайне редко ломаются и всегда подходят друг другу. Благодаря этому ребенок всегда получается результат в соответствии с приложенными усилиями, что положительно влияет на его самооценку.

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

Альтернативное мнение

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

Говоря об упрощении, следует отметить, что, выбирать конструктор и правила игры с ним нужно в соответствии с возрастом ребенка. Любая игрушка будет способствовать развитию ребенка только в том случае, если у ребенка не всё получается с первого раза. Иногда малыши сами пытаются создать всё более и более сложные модели, иногда может помочь вовремя заданный взрослым вопрос. Дети вырастают из своих игрушек, и это является признаком их развития, а Лего как раз позволяет наращивать сложность с помощью докупки новых наборов или изменения целей игры.

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

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

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

Нестандартные идеи

Универсальность элементов конструктора позволяет ему выходить за пределы игровой зоны. Существует множество нестандартных идей использования Лего для развития и организации досуга детей.

Предметы быта из конструктора Лего

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

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

Конструкторы в обучении

Последнее время всё больше педагогов используют конструкторы в качестве наглядного материала при обучении письму и чтению, развитию мышления, памяти и внимания малыша. Сложение и вычитание, умножение и деление объясняется проще при использовании блоков разных размеров. Нанесенные на блоки буквы позволяют сделать обучение чтению по-настоящему занимательным процессом. Работая с конструктором, ребенок подключает физическую активность к процессу обучения, что делает этот процесс гораздо более эффективным и интересным. Вот один из примеров развивающих игр из конструктора Лего:

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

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

Вывод

Конструкторы являются прекрасной развивающей игрушкой для детей разных возрастов. Современные наборы предоставляют большой выбор способов игры: от создания простой модели по схеме до проектирования и создания радиоуправляемых роботов своими руками. Занятия с конструкторами развивают пространственное и логическое мышление, произвольное внимание, речь и коммуникативные способности детей, учат их планировать свою деятельность и контролировать процесс выполнения задач, развивают их личностные качества. Различные способы организации игры детей задействуют разные сферы их развития, а использование конструкторов в качестве учебного материала делает игру в конструктор элементом обучения чтению и счету.

Заключение

Самостоятельная игра ребенка в Лего – это только один из способов использования конструктора для развития детей. Часто у родителей нет времени и сил для регулярных и разнообразных игр с ребенком, а возможности квартиры не позволяют пригласить ораву сверстников для совместных игр.

В этих случаях выручают уютные детские клубы, где малыш может поучаствовать в оригинальных развивающих играх и получить опыт общения с ровесниками. Педагоги детских Монтессори центров «Созвездие» регулярно обновляют свою картотеку развивающих игр и часто включают в них индивидуальные и групповые игры с конструкторами. Расписание каждого центра создается так, чтобы соответствовать потребностям разных семей: у нас есть группы полного дня, утренние и вечерние группы, а также отдельные кружки для детей всех возрастов.

А для особых фанатов конструктора Лего мы открыли кружок Лего-конструирования в нашем филиале в Куркино, на котором малыши создают индивидуальные и групповые модели при поддержке наших увлеченных педагогов.

С нетерпением ждём знакомства с Вами в наших Монтессори клубах «Созвездие»!

Статью подготовила Монтессори-педагог
Соколова Оксана

php - Вызываются ли родительские конструкторы, если дочерний класс НЕ определяет конструктор?

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
.

наследование - Java: как может быть класс конструктора дочернего класса нейтрализовать родительский конструктор?

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
.

c # - Можно ли вернуть дочерний класс из конструктора его родительского класса

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
.

11.4 - Конструкторы и инициализация производных классов

Автор Alex, 9 января 2008 г. | последнее изменение: nascardriver: 27 января 2020 г.

В последних двух уроках мы изучили некоторые основы наследования в C ++ и порядок инициализации производных классов. В этом уроке мы более подробно рассмотрим роль конструкторов в инициализации производных классов. Для этого мы продолжим использовать простые классы Base и Derived, которые мы разработали на предыдущем уроке:

1

2

3

4

5

6

7

8

9

10

11

12

13

140002

14

18

19

20

21

22

23

24

25

class Base

{

public:

int m_id;

База (int id = 0)

: m_id {id}

{

}

int getId () const {return m_id; }

};

класс Получено: общедоступная база

{

общедоступная:

двойная m_cost;

Получено (двойная стоимость = 0.0)

: m_cost {cost}

{

}

double getCost () const {return m_cost; }

};

В случае с непроизводными классами конструкторам нужно заботиться только о своих членах. Например, рассмотрим Base. Мы можем создать базовый объект следующим образом:

int main ()

{

Базовая база {5}; // использовать конструктор Base (int)

return 0;

}

Вот что на самом деле происходит при создании экземпляра базы:

  1. Память для базы отведена
  2. Вызывается соответствующий конструктор Base
  3. Список инициализации инициализирует переменные
  4. Тело конструктора выполняет
  5. Управление возвращено вызывающей стороне

Это довольно просто.С производными классами дело обстоит немного сложнее:

int main ()

{

Производный производный {1.3}; // использовать производный (двойной) конструктор

return 0;

}

Вот что на самом деле происходит при создании производного экземпляра:

  1. Память для производных отложена (достаточно как для базовой, так и для производной части)
  2. Вызывается соответствующий производный конструктор.
  3. Объект Base создается первым с использованием соответствующего конструктора Base .Если базовый конструктор не указан, будет использоваться конструктор по умолчанию.
  4. Список инициализации инициализирует переменные
  5. Тело конструктора выполняет
  6. Управление возвращено вызывающей стороне

Единственное реальное различие между этим случаем и ненаследуемым случаем состоит в том, что до того, как конструктор Derived сможет сделать что-либо существенное, сначала вызывается конструктор Base. Конструктор Base устанавливает базовую часть объекта, управление возвращается конструктору Derived, а конструктору Derived разрешается завершить свою работу.

Инициализация членов базового класса

Один из текущих недостатков нашего класса Derived в том виде, в котором он написан, заключается в том, что нет возможности инициализировать m_id при создании объекта Derived. Что, если мы хотим установить и m_cost (из производной части объекта), и m_id (из базовой части объекта), когда мы создаем производный объект?

Новые программисты часто пытаются решить эту проблему следующим образом:

класс Получено: общедоступная база

{

общедоступная:

двойная m_cost;

Получено (двойная стоимость = 0.0, int id = 0)

// не работает

: m_cost {cost}, m_id {id}

{

}

double getCost () const {return m_cost; }

};

Это хорошая попытка и почти правильная идея. Нам обязательно нужно добавить еще один параметр в наш конструктор, иначе C ++ не сможет узнать, какое значение мы хотим инициализировать m_id.

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

Почему C ++ это делает? Ответ связан с константными и ссылочными переменными. Подумайте, что бы произошло, если бы m_id было const. Поскольку константные переменные должны быть инициализированы значением во время создания, конструктор базового класса должен установить свое значение при создании переменной. Однако по завершении работы конструктора базового класса выполняются списки инициализации конструкторов производного класса.Тогда каждый производный класс получит возможность инициализировать эту переменную, потенциально изменяя ее значение! Ограничивая инициализацию переменных конструктором класса, к которому эти переменные принадлежат, C ++ гарантирует, что все переменные инициализируются только один раз.

Конечным результатом является то, что приведенный выше пример не работает, потому что m_id был унаследован от Base, и только ненаследуемые переменные могут быть инициализированы в списке инициализации.

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

класс Получено: общедоступная база

{

общедоступная:

двойная m_cost;

Получено (двойная стоимость = 0,0, int id = 0)

: m_cost {cost}

{

m_id = id;

}

double getCost () const {return m_cost; }

};

Хотя в данном случае это действительно работает, это не сработало бы, если бы m_id было константой или ссылкой (потому что значения констант и ссылки должны быть инициализированы в списке инициализации конструктора).Это также неэффективно, потому что m_id дважды присваивается значение: один раз в списке инициализации конструктора базового класса, а затем снова в теле конструктора производного класса. И, наконец, что, если базовому классу потребовался доступ к этому значению во время построения? У него нет возможности получить к нему доступ, поскольку он не устанавливается до тех пор, пока не будет выполнен конструктор Derived (что в значительной степени происходит в последнюю очередь).

Итак, как правильно инициализировать m_id при создании объекта производного класса?

До сих пор во всех примерах, когда мы создавали экземпляр объекта производного класса, часть базового класса была создана с использованием базового конструктора по умолчанию.Почему он всегда использует конструктор Base по умолчанию? Потому что мы никогда не говорили иначе!

К счастью, C ++ дает нам возможность явно выбирать, какой конструктор базового класса будет вызываться! Для этого просто добавьте вызов базового класса Constructor в список инициализации производного класса:

класс Получено: общедоступная база

{

общедоступная:

двойная m_cost;

Получено (двойная стоимость = 0.0, int id = 0)

: Base {id}, // Вызов конструктора Base (int) со значением id!

m_cost {cost}

{

}

double getCost () const {return m_cost; }

};

Теперь, когда мы выполняем этот код:

int main ()

{

Производный производный {1.3, 5}; // использовать конструктор Derived (double, int)

std :: cout << "Id:" << производный.getId () << '\ n';

std :: cout << "Стоимость:" << производное.getCost () << '\ n';

возврат 0;

}

Конструктор базового класса Base (int) будет использоваться для инициализации m_id значением 5, а конструктор производного класса будет использоваться для инициализации m_cost значением 1.3!

Таким образом, программа напечатает:

 Id: 5 Стоимость: 1.3 

Более подробно, вот что происходит:

  1. Выделена память для производных.
  2. Вызывается конструктор Derived (double, int), где cost = 1.3, а id = 5
  3. Компилятор проверяет, запросили ли мы конкретный конструктор базового класса. У нас есть! Поэтому он вызывает Base (int) с id = 5.
  4. Список инициализации конструктора базового класса устанавливает m_id равным 5
  5. Выполняется тело конструктора базового класса, которое ничего не делает
  6. Конструктор базового класса возвращает
  7. Список инициализации конструктора производного класса устанавливает m_cost равным 1.3
  8. Выполняется тело конструктора производного класса, которое ничего не делает
  9. Конструктор производного класса возвращает

Это может показаться несколько сложным, но на самом деле это очень просто. Все, что происходит, - это то, что конструктор Derived вызывает конкретный конструктор Base для инициализации базовой части объекта. Поскольку m_id находится в базовой части объекта, конструктор Base является единственным конструктором, который может инициализировать это значение.

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

Теперь мы можем сделать наших участников приватными

Теперь, когда вы знаете, как инициализировать члены базового класса, нет необходимости держать наши переменные-члены общедоступными. Мы снова делаем наши переменные-члены закрытыми, как и должно быть.

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

Рассмотрим:

1

2

3

4

5

6

7

8

9

10

11

12

13

140002

14

18

19

20

21

22

23

24

25

26

27

28

29

30

000

34

35

36

37

38

39

#include

class Base

{

private: // теперь наш участник закрытый

int m_id;

общедоступный:

База (int id = 0)

: m_id {id}

{

}

int getId () const {return m_id; }

};

class Производные: общедоступная База

{

закрытая: // теперь наш член закрытый

double m_cost;

общедоступный:

Получено (двойная стоимость = 0.0, int id = 0)

: Base {id}, // Вызов конструктора Base (int) со значением id!

m_cost {cost}

{

}

double getCost () const {return m_cost; }

};

int main ()

{

Производный производный {1.3, 5}; // использовать конструктор Derived (double, int)

std :: cout << "Id:" << производный.getId () << '\ n';

std :: cout << "Стоимость:" << производное.getCost () << '\ n';

возврат 0;

}

В приведенном выше коде мы сделали m_id и m_cost приватными. Это нормально, поскольку мы используем соответствующие конструкторы для их инициализации и общедоступный метод доступа для получения значений.

Это напечатает, как и ожидалось:

 Id: 5 Стоимость: 1.3 

Подробнее о спецификаторах доступа мы поговорим в следующем уроке.

Другой пример

Давайте взглянем на еще одну пару классов, с которыми мы ранее работали:

1

2

3

4

5

6

7

8

9

10

11

12

13

140002

14

18

19

20

21

22

23

24

25

26

27

28

29

30

#include

class Person

{

public:

std :: string m_name;

int m_age;

Человек (const std :: string & name = "", int age = 0)

: m_name {name}, m_age {age}

{

}

const std :: string & getName ( ) const {return m_name; }

int getAge () const {return m_age; }

};

// BaseballPlayer, публично наследующий Person

class BaseballPlayer: public Person

{

public:

double m_battingAverage;

int m_homeRuns;

BaseballPlayer (среднее значение двойного удара = 0.0, int homeRuns = 0)

: m_battingAverage {battingAverage},

m_homeRuns {homeRuns}

{

}

};

Как мы уже писали ранее, BaseballPlayer инициализирует только свои собственные члены и не указывает конструктор Person для использования. Это означает, что каждый созданный нами BaseballPlayer будет использовать конструктор Person по умолчанию, который инициализирует имя пустым и возрастом до 0. Поскольку имеет смысл дать нашему BaseballPlayer имя и возраст при их создании, мы должны изменить этот конструктор на добавьте эти параметры.

Вот наши обновленные классы, которые используют частные члены, причем класс BaseballPlayer вызывает соответствующий конструктор Person для инициализации унаследованных переменных-членов Person:

1

2

3

4

5

6

7

8

9

10

11

12

13

140002

14

18

19

20

21

22

23

24

25

26

27

28

29

30

000

34

35

36

37

#include

#include

class Person

{

private:

std :: string m_name;

int m_age;

public:

Person (const std :: string & name = "", int age = 0)

: m_name {name}, m_age {age}

{

}

const std: : строка & getName () const {return m_name; }

int getAge () const {return m_age; }

};

// BaseballPlayer публично наследует Person

class BaseballPlayer: public Person

{

private:

double m_battingAverage;

int m_homeRuns;

public:

BaseballPlayer (const std :: string & name = "", int age = 0,

double battingAverage = 0.0, int homeRuns = 0)

: Person {name, age}, // вызов Person (const std :: string &, int) для инициализации этих полей

m_battingAverage {battingAverage}, m_homeRuns {homeRuns}

{

}

double getBattingAverage () const {return m_battingAverage; }

int getHomeRuns () const {return m_homeRuns; }

};

Теперь мы можем создавать таких бейсболистов:

int main ()

{

BaseballPlayer pedro {"Pedro Cerrano", 32, 0.342, 42};

std :: cout << pedro.getName () << '\ n';

std :: cout << pedro.getAge () << '\ n';

std :: cout << pedro.getHomeRuns () << '\ n';

возврат 0;

}

Это выводит:

 Педро Серрано 32 42 

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

Цепи наследования

Классы в цепочке наследования работают точно так же.

1

2

3

4

5

6

7

8

9

10

11

12

13

140002

14

18

19

20

21

22

23

24

25

26

27

28

29

30

000

34

35

36

37

#include

class A

{

public:

A (int a)

{

std :: cout << "A:" << a << '\ n ';

}

};

класс B: общедоступный A

{

общедоступный:

B (int a, double b)

: A {a}

{

std :: cout << "B:" << << б << '\ п';

}

};

класс C: общедоступный B

{

общедоступный:

C (int a, double b, char c)

: B {a, b}

{

std :: cout << " C: «<< c << '\ n';

}

};

int main ()

{

C c {5, 4.3, 'R'};

возврат 0;

}

В этом примере класс C является производным от класса B, производного от класса A. Итак, что происходит, когда мы создаем экземпляр объекта класса C?

Сначала main () вызывает C (int, double, char). Конструктор C вызывает B (int, double). Конструктор B вызывает A (int). Поскольку A не наследуется ни от кого, это первый класс, который мы создадим. A создается, выводит значение 5 и возвращает управление B.B создается, выводит значение 4.3 и возвращает управление C. C создается, выводит значение «R» и возвращает управление main (). Готово!

Таким образом, эта программа напечатает:

 А: 5 А: 4,3 C: R 

Стоит отметить, что конструкторы могут вызывать конструкторы только из их непосредственного родительского / базового класса. Следовательно, конструктор C не может напрямую вызывать или передавать параметры конструктору A. Конструктор C может вызывать только конструктор B (который отвечает за вызов конструктора A).

Деструкторы

Когда производный класс уничтожается, каждый деструктор вызывается в порядке построения , обратном . В приведенном выше примере, когда c уничтожается, сначала вызывается деструктор C, затем деструктор B, а затем деструктор A.

Сводка

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

На этом этапе вы теперь достаточно понимаете наследование C ++, чтобы создавать свои собственные унаследованные классы!

Время викторины!

1) Давайте реализуем наш пример Fruit, о котором мы говорили во введении в наследование. Создайте базовый класс Fruit, содержащий два закрытых члена: имя (std :: string) и цвет (std :: string).Создайте класс Apple, унаследованный от Fruit. У Apple должен быть дополнительный частный член: fiber (double). Создайте класс Banana, который также наследует Fruit. У Banana нет дополнительных участников.

Должна запуститься следующая программа:

int main ()

{

const Apple a {"Красный вкусный", "красный", 4.2};

std :: cout << a << '\ n';

const Banana b {"Кавендиш", "желтый"};

std :: cout << b << '\ n';

возврат 0;

}

И выведите следующее:

 Яблоко (Красный вкусный, красный, 4.2) Банан (Кавендиш, желтый) 

Совет: поскольку a и b являются константами, вам нужно помнить о своих константах. Убедитесь, что ваши параметры и функции имеют значение const.

Показать решение

1

2

3

4

5

6

7

8

9

10

11

12

13

140002

14

18

19

20

21

22

23

24

25

26

27

28

29

30

000

34

35

36

37

38

39

40

41

42

43

44

45

46

49

0002 47

00030002 47

0003

51

52

53

54

55

56

57

58

59

60

61

62

63

9 0002 64

65

66

67

#include

#include

class Fruit

{

private:

std :: string m_name;

std :: string m_color;

public:

Fruit (const std :: string & name, const std :: string & color)

: m_name {name}, m_color {color}

{

}

const std :: строка & getName () const {return m_name; }

const std :: string & getColor () const {return m_color; }

};

класс Apple: общественный Fruit

{

частный:

двойной m_fiber;

public:

Apple (const std :: string & name, const std :: string & color, double fiber)

: Fruit {name, color},

m_fiber {fiber}

{

}

двойной getFiber () const {return m_fiber; }

};

std :: ostream & operator << (std :: ostream & out, const Apple & a)

{

out << "Apple (" << a.getName () << "," << a.getColor () << "," << a.getFiber () << ')';

возврат;

}

class Banana: public Fruit

{

public:

Banana (const std :: string & name, const std :: string & color)

: Fruit {name, color}

{

}

};

std :: ostream & operator << (std :: ostream & out, const Banana & b)

{

out << "Banana (" << b.getName () << "," << b.getColor () << ')';

возврат;

}

int main ()

{

const Apple a {"Красный вкусный", "красный", 4.2};

std :: cout << a << '\ n';

const Banana b {"Кавендиш", "желтый"};

std :: cout << b << '\ n';

возврат 0;

}


.

Смотрите также