¿Debo pasar un RPP compartido por referencia? [duplicar]

En circunstancias controladas puede pasar el puntero compartido por referencia constante. Asegúrese de que nadie está borrando el objeto simultáneamente, aunque esto no debería ser demasiado difícil si tiene cuidado con a quién le da referencias.

En general, debe pasar el puntero compartido como una copia recta . Esto le da su semántica prevista: Cada ámbito que contiene una copia del puntero compartido mantiene vivo el objeto en virtud de su "compartir" en el propiedad.

La única razón para no pasar siempre por valor es que copiar un puntero compartido tiene un precio determinado debido a la actualización del recuento de referencias atómicas; sin embargo, esto podría no ser una preocupación importante.

Digresión opcional:

Dado que la pregunta principal ha sido respondida, tal vez sea instructivo considerar algunas maneras en las que debería nunca usar un puntero compartido. Aquí hay un pequeño experimento mental. Definamos un espacio compartido tipo de puntero SF = std::shared_ptr<Foo>. Para considerar las referencias, en lugar de pasar argumentos de función, veamos el tipo RSF = std::reference_wrapper<T>. Es decir, si tenemos un puntero compartido SF p(std::make_shared<Foo>());, entonces podemos hacer una envoltura de referencia con semántica de valores a través de RSF w = std::ref(p);. Demasiado para la configuración.

Ahora, todo el mundo sabe que los contenedores de punteros son campos minados. Así que std::vector<Foo*> será una pesadilla para mantener, y cualquier número de errores surgen de la gestión inadecuada de la vida. Lo que es peor conceptualmente es que nunca está claro quién posee los objetos cuyos punteros almacena el contenedor. Los punteros incluso podrían ser una mezcla de punteros a objetos dinámicos, objetos automáticos y basura. Nadie lo sabe. Así que la solución estándar es usar std::vector<SF> en su lugar. Esta es La Forma Correcta de usar el puntero compartido. Por otro lado, lo que nunca debes usar es std::vector<RSF> this ¡este es un monstruo inmanejable que en realidad es muy similar al vector original de los punteros desnudos! Por ejemplo, no está claro si el objeto al que mantener una referencia sigue vivo. Tomar una referencia del puntero compartido ha derrotado todo su propósito.

Para un segundo ejemplo, supongamos que tenemos un puntero compartido SF p como antes. Ahora tenemos una función int foo(SF) que queremos ejecutar simultáneamente. El std::thread(foo, p) habitual funciona bien, ya que el constructor de subprocesos hace una copia de sus argumentos. Sin embargo, si hubiéramos dicho std::thread(foo, std::ref(p)), estaríamos en todo tipo de problemas: El puntero compartido en el ámbito de llamada podría caducar y destruir el objeto, ¡y te quedarías con una referencia colgando y un puntero inválido!

Espero que estos dos ejemplos bastante ingeniosos arrojen un poco de luz sobre cuándo realmente quieres que tus punteros compartidos sean pasados por copy. En un programa bien diseñado, siempre debe estar claro quién es responsable de qué recursos, y cuando se usa correctamente, el puntero compartido es una gran herramienta para el trabajo.