Передача unique_ptr в функции

Question

Я пытаюсь «модернизировать» существующий код.

• У меня есть класс, который в настоящее время имеет переменную-член «Устройство * устройство_».
• Он использует новое для создания экземпляра в некотором коде инициализации и имеет «delete device_» в деструктории.
• Функции-члены этого класса звонят многие другие функции, которые принимают устройство * в качестве параметра.

Это хорошо работает, но «модернизировать» мой код, я думал, что я должен изменить переменную быть определена как "std::unique_ptr<Device> device_" и удалить явный вызов удаления, что делает код более безопасным и в целом лучше.

Мой вопрос заключается в следующем -

• Как я должен затем передать устройство _ переменной для всех функций, которые нуждаются в ней в качестве В параметре?

Я могу позвонить .get, чтобы получить необработанный указатель в каждом вызове функции. Но это кажется уродливым и отпугивает некоторые причины использовать unique_ptr в первую очередь.

Или я могу изменить каждую функцию так, что вместо того, чтобы параметр типа «Device *» теперь принимает типа В параметре «станд :: unique_ptr &». Который (для меня) несколько запутывает прототипы функций и затрудняет их чтение.

Что лучше всего подходит для этого? Я пропустил другие варианты?

Answer 1

В современном стиле C++, есть две клавиши понятия:

• собственности
• Недействительность

собственности о владельце некоторого объекта/ресурса (в данном случае , экземпляр Device). Различные std::unique_ptr, boost::scoped_ptr или std::shared_ptr касаются собственности.

Nullity намного проще: он просто выражает, может ли данный объект быть нулевым, и не заботится ни о чем другом, и, конечно, не о праве собственности!

---

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

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

---

С другой стороны, большинство пользователей ресурсов не мог заботиться меньше о своей собственности.

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

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

• Никогда нулевой? Pass a ссылка
• Возможно, null?Проходят указатель, простой голый указатель или указатель типа класса (с ловушкой на нуль, например)

---

Answer 2

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

Answer 3

Это может быть неосуществимо для вас, но замена любого места Device* на const unique_ptr<Device>& - хорошее начало.

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

Теперь у вас есть ловушка, вы должны пройти мимо const &, чтобы не допустить совершения звонков unique_ptr.reset() или unique_ptr().release(). Обратите внимание, что это все еще передает изменяемый указатель на устройство. С помощью этого решения у вас нет простого способа передать указатель или ссылку на const Device.

Answer 4

На самом деле это зависит. Если функция должна принадлежать unique_ptr, то ее подпись должна принимать значение unique_ptr<Device> bv значение, а вызывающий должен указать std::move указатель. Если право собственности не является проблемой, я бы сохранил необработанную подпись указателя и передал указатель unique_ptr, используя get(). Это не уродливо , если функция, о которой идет речь, не приобретает права собственности.

Answer 5

Лучшая практика, вероятно, не использовать std::unique_ptr в этом случае, , хотя это зависит. (Обычно у вас должно быть не более одного необработанного указателя для динамически выделенного объекта в классе. Хотя это и зависит от .) Единственное, что вы не хотите делать в этом случае: , проходящее вокруг std::unique_ptr (и как вы заметили, что std::unique_ptr<> const& немного громоздкий и запутывающий). Если этот является единственным динамически выделенным указателем в объекте, я бы просто нажал с необработанным указателем и delete в деструкторе. Если есть несколько таких указателей, я бы рассмотрел вопрос о переносе каждого из них в отдельный базовый класс (где они все еще могут быть необработанными указателями).