Передача общих указателей в качестве аргументов

Если я объявляю объект, заключенный в общий указатель:

std::shared_ptr<myClass> myClassObject(new myClass());

затем я хотел передать его как аргумент методу:

DoSomething(myClassObject);

//the called method
void DoSomething(std::shared_ptr<myClass> arg1)
{
   arg1->someField = 4;
}

Это просто увеличивает счетчик ссылок shared_pt, и все в порядке? Или он оставляет висящий указатель?

Вы все еще должны это делать ?:

DoSomething(myClassObject.Get());

void DoSomething(std::shared_ptr<myClass>* arg1)
{
   (*arg1)->someField = 4;
}

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

Спасибо.

Я хочу передать общий указатель на функцию. Вы можете мне с этим помочь?

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

Да, я достаточно доволен этой темой.

Хороший.

Хорошо, я могу придумать только две причины, чтобы shared_ptrпоспорить:

1. Функция хочет разделить владение объектом;
2. Функция выполняет некоторую операцию, которая работает конкретно с shared_ptrs.

Что вас интересует?

Я ищу общий ответ, поэтому меня действительно интересуют оба варианта. Мне любопытно, что вы имеете в виду в случае № 2.

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

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

В яблочко.

В таком случае, я думаю, нам следует перейти по ссылке.

Да. И если он не меняет указатель, вы хотите передать по константной ссылке. Нет необходимости копировать, так как вам не нужно делить владение. Это другой сценарий.

Хорошо понял. Поговорим о другом сценарии.

Тот, где вы разделяете собственность? ОК. Как вы делите собственность с shared_ptr?

Копируя это.

Тогда функции нужно будет сделать копию shared_ptr, правильно?

Очевидно. Итак, я передаю его по ссылке на const и копирую в локальную переменную?

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

Хорошая точка зрения. Я должен чаще вспоминать эту статью « Хотите скорости? Передайте по значению ».

Подождите, а что, если функция хранит shared_ptr, например, в переменной-члене? Разве это не будет дублирующей копией?

Функция может просто переместить shared_ptrаргумент в свое хранилище. Перемещение a shared_ptrобходится дешево, потому что не меняет счетчик ссылок.

Ах, хорошая идея.

Но я думаю о третьем сценарии: что, если вы не хотите shared_ptrни манипулировать собственностью , ни делиться ею?

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

И брать указателя по ссылке или по стоимости?

Применяются обычные правила. Умные указатели ничего не меняют.

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

Правильно.

Хм. Думаю, вы забыли еще один сценарий. Что, если я хочу разделить собственность, но только при определенных условиях?

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

Я рискую одной дублирующей копией в первом варианте и теряю потенциальный ход во втором. Разве я не могу съесть торт и тоже?

Если вы находитесь в ситуации, когда это действительно важно, вы можете предоставить две перегрузки: одна принимает ссылку на const lvalue, а другая - ссылку на rvalue. Один копирует, другой двигается. Другой вариант - шаблон функции идеальной пересылки.

Я думаю, это охватывает все возможные сценарии. Большое спасибо.

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

void DoSomething(myClass * p);

DoSomething(myClass_shared_ptr.get());
DoSomething(myClass_unique_ptr.get());

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

Да, вся идея shared_ptr <> заключается в том, что несколько экземпляров могут содержать один и тот же необработанный указатель, а базовая память будет освобождена только тогда, когда будет уничтожен последний экземпляр shared_ptr <>.

Я бы избегал указателя на shared_ptr <>, поскольку это противоречит цели, поскольку теперь вы снова имеете дело с raw_pointers.

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

в своей функции DoSomething вы изменяете член данных экземпляра класса, myClass поэтому вы изменяете управляемый объект (необработанный указатель), а не объект (shared_ptr). Это означает, что в точке возврата этой функции все общие указатели на управляемый необработанный указатель будут видеть свой член данных: myClass::someFieldизмененный на другое значение.

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

Идиома, чтобы выразить это через: const ref, например

void DoSomething(const std::shared_ptr<myClass>& arg)

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

ПРЕДОСТЕРЕЖЕНИЕ: это означает, что если каким-то образом кто-то вызывает shared_ptr::resetперед тем, как вы вызываете вашу функцию, и в этот момент это последний shared_ptr, владеющий raw_ptr, то ваш объект будет уничтожен, а ваша функция будет управлять свисающим указателем на уничтоженный объект. ОЧЕНЬ ОПАСНО!!!