вопросы относительно shared_from_this

1) Это зависит от того, что вы подразумеваете под «сделать это» относительно того, можете ли вы это сделать. Вы всегда можете построить shared_ptr из необработанного указателя, такого как this, но он не будет делиться счетчиком ссылок с другим экземпляром shared_ptr, который был создан отдельно от необработанного указателя. Таким образом, вам нужно будет использовать настраиваемое средство удаления в том или ином экземпляре, чтобы избежать двойного удаления, но если вы не проявите большую осторожность, вы можете получить висячие экземпляры shared_ptr из-за того, что объект удаляется через один, но все еще доступен из другого.

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

2) Для вызова shared_from_this() требуется, чтобы хотя бы один экземпляр shared_ptr уже указывал на ваш объект. Если вы используете его на автоматическом объекте без экземпляра shared_ptr с пользовательским средством удаления, вы получите плохие вещи.

3) Если вы унаследованы от своего класса, то функциональность enable_shared_from_this даст вам shared_ptr базового класса (того, который получен от enable_shared_from_this). Затем вы можете использовать static_pointer_cast или dynamic_pointer_cast для приведения результата shared_from_this() к указателю на производный класс.

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

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

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

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

1) Нет, это невозможно сделать без shared_from_this. Вы можете просто создать shared_ptr с помощью удаления без операций:

void do_nothing(MyClass*) {}

void MyClass:memfun()
{
    func(shared_ptr<MyClass>(this, do_nothing));
}

Ввиду того, что вам на самом деле не нужен shared_from_this, я пропущу следующие две части вашего вопроса.

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

Это полезно для статических объектов. Если у него действительно есть локальное автоматическое хранилище, вам нужно спросить себя, почему функция использует shared_ptr. Он их хранит?

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

В дополнение к Дэвиду Родригесу - dribeas, общий указатель не рекомендуется google< /а>