Теперь,
когда мы с вами познакомились с возможностями shared_ptr, а конкретно с
главной его возможностью, что его в отличие от unique_ptr можно копировать,
мы готовы изменить решение задачи для дерева выражений таким образом,
чтобы удовлетворить наше новое требование.
Вот здесь у нас авторское решение с помощью unique_ptr'ов.
Оно у нас собрано.
Давайте его запустим и видим, что оно у нас печатает e1,
затем печатает e2, снова печатает e1,
но при этом в e1 у нас ничего не осталось, поэтому выводится строка,
что Null expression, потому что из e1 мы переместили.
Хорошо, давайте напишем решение с помощью shared_ptr'ов.
Начнем с того, что все умные указатели, которые здесь используются,
переделаем с unique_ptr на shared_ptr.
Вот здесь был unique_ptr, пишем shared_ptr.
Так. И дальше у нас есть функции,
которые создают новые объекты.
Они у нас вызывают make_unique.
Здесь соответственно тоже вместо make_unique нам нужно использовать
make_shared, хорошо, здесь напишем make_shared.
И как мы помним, shared_ptr умеет делать все то же самое, что и unique_ptr.
Поэтому такую программу мы уже можем собрать, вот она у нас собралась.
Запустить.
Она у нас будет выводить все то же самое,
но при этом она работает уже на shared_ptr'ах.
И теперь вопрос к вам: как нужно изменить функцию main, чтобы повторное обращение
функции Print для e1 у нас выводило не строчку о том, что там нулевой указатель,
а чтобы оно точно так же снова выводило содержимое дерева e1?
Ну, почему у нас вообще там выводилось
сообщение о том, что у нас нулевое выражение?
Потому что мы переместили из указателя e1.
В случае с unique_ptr выхода у нас не было, нам нужно было перемещать.
Но у нас же теперь shared_ptr,
соответственно нам нужно вместо перемещения использовать копирование.
И ответ очень простой: нам нужно удалить функцию move.
То есть теперь вместо перемещения у нас будет использоваться копирование.
То есть вот здесь у нас мы просто пишем сумму e1.
Отлично, давайте посмотрим, как работает такое исправление.
Компилируем, запускаем нашу программу и видим, что все отлично работает.
То есть мы снова обратились по указателю e1 и напечатали исходное дерево.
Хорошо.
Давайте теперь проверим, что у нас действительно при удалении
указателя e2 то наше поддерево, на которое указывает e1, останется без изменений.
То есть, что shared_ptr в данном случае лучше, чем сырой указатель.
Так.
Давайте заключим создание вот этого e2 и его распечатывания в блок,
и как мы знаем, у нас e2 будет уничтожен по выходу из блока.
Проверим, что у нас e1 будет продолжать работать.
Соберем такую программу.
Так, и запустим ее, и видим, что у нас вывод корректный,
то есть действительно у нас то поддерево, на которое указывает e1,
оно не пострадало, несмотря на то, что e2 удалилось.
То есть все работает нормально.
Но вот уберем этот блок.
А теперь смотрите, на самом деле мы можем делать даже более интересные вещи здесь.
Например, давайте заведем такой ExpressionPtr e3,
который будет равен сумме e1 и e2,
и напечатаем уже вот такой e3.
Так, e3.get().
И теперь вопрос к вам: как вы думаете,
что напечатает вот эта последняя строчка Print(e3)?
Давайте соберем программу и посмотрим, что же она на самом деле напечатает.
Так, мы запускаем и видим, что она работает на самом деле абсолютно логично.
Что здесь написано?
Сумма e1 и e2.
e1 мы знаем, вот у нас первая строчка, e2 мы тоже знаем, вот вторая строчка.
Значит, e1 + e2 — это просто их сумма.
А то, что на самом деле там дерево e1 входит в это выражение дважды,
это сути дела не меняет, все и так отлично работает, как раз потому что
shared_ptr отлично умеет указывать на один и тот же узел из нескольких мест.
Хорошо, давайте теперь рассмотрим чуть подробнее,
как же у нас эти узлы расположены в памяти и друг на друга ссылаются.
Вот так у нас теперь создается дерево выражений для e2,
отличие в том, что мы убрали функцию move.
То есть теперь указатель e1 мы не перемещаем, а копируем.
Здесь вызывается Value для 5, возвращает временный в данном
случае уже shared_ptr на новый объект, который хранит пятерку.
И дальше вот этот временный shared_ptr перемещается
внутри функции Sum, а e1 не перемещается,
e1 копируется, потому что временные объекты всегда по умолчанию перемещаются.
Как вы знаете, так работает семантика перемещения.
А вот e1, мы ему не сказали в явном виде перемещаться, значит,
он у нас будет копироваться.
И Sum создает нам новый узел SumExpr, который в себе сохраняет указатели
на вот эти два узла на пятерку умножения и сохраняет результат в указатель e2.
Теперь давайте посмотрим, а как у нас происходит удаление e2.
Для этого мы немного раскроем этот узел SumExpr,
чтобы заглянуть внутрь, что у него там происходит.
И посмотрим, собственно, по шагам, как будет удаляться e2.
Итак, начинается удаление e2.
Это shared_ptr, он указывает на узел SumExpr, начинает удалять SumExpr.
SumExpr при своем удалении начинает удалять свои поля, начинает с поля right.
Видит, что ссылается на 5, значит, удаляет 5.
Дальше он начинает удалять поле left, поле left ссылается на узел умножения.
И вот тут самое интересное: shared_ptr видит,
что на этот узел умножения кроме него ссылается еще другой shared_ptr — e1,
и поэтому он не будет удалять этот узел.
Он просто удалится сам, а узел трогать не будет.
На этом удаление SumExpr заканчивается, и удаление e2 тоже заканчивается.
А поддерево e1 у нас остается без изменений.
Теперь давайте посмотрим на вот этот наш пример,
когда мы сделали сумму выражений e1 и e2.
Очень интересно: создается новый узел e3, при этом и e1,
и e2 копируются в функцию Sum, она создает новый узел e3, который
ссылается вот на уже существующие узлы, которые адресуются указателями e1 и e2.
И все прекрасно работает, никаких проблем на самом деле с этим нет.
Если на unique_ptr'ах у нас было дерево,
то на shared_ptr'ах мы смогли сделать направленный ациклический граф.
При этом, опять же, если в случае с unique_ptr'ами у нас получался рекурсивный
обход, абсолютно бесплатный, компилятор сам его делал, здесь точно так же: то,
что это граф, и то, что в нем нет циклов,
нам гарантирует просто семантика работы с shared_ptr'ами.
Вот таким по сути тривиальным изменением нашей реализации на unique_ptr'ах,
просто заменив их на shared_ptr'ы, мы смогли реализовать новое требование.
А в следующих видео мы с вами более подробно поговорим
уже о внутреннем устройстве этих умных указателей.
