Pasar punteros compartidos como argumentos

Si declaro un objeto envuelto en un puntero compartido:

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

luego quería pasarlo como argumento a un método:

DoSomething(myClassObject);

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

¿Lo anterior simplemente incrementa el recuento de referencias de shared_pt y todo está bien? ¿O deja un puntero colgando?

¿Todavía se supone que debes hacer esto ?:

DoSomething(myClassObject.Get());

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

Creo que la segunda forma puede ser más eficiente porque solo tiene que copiar 1 dirección (a diferencia de todo el puntero inteligente), pero la primera forma parece más legible y no anticipo empujar los límites de rendimiento. Solo quiero asegurarme de que no haya nada peligroso al respecto.

Gracias.

Quiero pasar un puntero compartido a una función. ¿Me puede ayudar con eso?

Claro, puedo ayudarte con eso. Supongo que tiene cierta comprensión de la semántica de propiedad en C ++. ¿Es eso cierto?

Sí, me siento razonablemente cómodo con el tema.

Bueno.

Ok, solo puedo pensar en dos razones para shared_ptrargumentar:

1. La función quiere compartir la propiedad del objeto;
2. La función realiza alguna operación que trabaja específicamente en shared_ptr s.

Cual te interesa?

Estoy buscando una respuesta general, así que estoy interesado en ambos. Sin embargo, tengo curiosidad por saber a qué te refieres con el caso n. ° 2.

Ejemplos de tales funciones incluyen std::static_pointer_cast comparadores personalizados o predicados. Por ejemplo, si necesita encontrar todos los shared_ptr únicos de un vector, necesita dicho predicado.

Ah, cuando la función realmente necesita manipular el puntero inteligente.

Exactamente.

En ese caso, creo que deberíamos pasar por referencia.

Si. Y si no cambia el puntero, desea pasar por referencia constante. No es necesario copiar, ya que no es necesario compartir la propiedad. Ese es el otro escenario.

Ok lo tengo. Hablemos del otro escenario.

¿En el que compartes la propiedad? Okay. ¿Cómo se comparte la propiedad conshared_ptr ?

Copiándolo.

Entonces la función necesitará hacer una copia de a shared_ptr, ¿correcto?

Obviamente. Entonces, ¿lo paso por una referencia a const y lo copio en una variable local?

No, eso es una pesimización. Si se pasa por referencia, la función no tendrá más remedio que realizar la copia manualmente. Si se pasa por valor, el compilador elegirá la mejor opción entre una copia y un movimiento y la realizará automáticamente. Entonces, pase por valor.

Buen punto. Debo recordar eso " ¿Quieres velocidad? Pasar por valor " con más frecuencia.

Espere, ¿y si la función almacena el shared_ptr en una variable miembro, por ejemplo? ¿No será una copia redundante?

La función puede simplemente mover el shared_ptrargumento a su almacenamiento. Mover unshared_ptr es barato porque no cambia ningún recuento de referencias.

Ah, buena idea.

Pero estoy pensando en un tercer escenario: ¿qué pasa si no quieres manipular shared_ptrni compartir la propiedad?

En ese caso, shared_ptres completamente irrelevante para la función. Si desea manipular el pointee, tome un pointee y deje que las personas que llaman elijan qué semántica de propiedad quieren.

¿Y debería tomar el pointee por referencia o por valor?

Se aplican las reglas habituales. Los punteros inteligentes no cambian nada.

Pasar por valor si voy a copiar, pasar por referencia si quiero evitar una copia.

Derecha.

Hmm. Creo que olvidaste otro escenario. ¿Qué sucede si quiero compartir la propiedad, pero solo dependiendo de una determinada condición?

Ah, un caso extremo interesante. No espero que eso suceda a menudo. Pero cuando suceda, puede pasar por valor e ignorar la copia si no la necesita, o pasar por referencia y hacer la copia si la necesita.

Me arriesgo a una copia redundante en la primera opción y pierdo un movimiento potencial en la segunda. ¿No puedo comerme el pastel y tenerlo también?

Si se encuentra en una situación en la que eso realmente importa, puede proporcionar dos sobrecargas, una tomando una referencia de valor constante y otra tomando una referencia de valor r. Uno copia, el otro se mueve. Una plantilla de función de reenvío perfecto es otra opción.

Creo que cubre todos los escenarios posibles. Muchas gracias.

Creo que la gente tiene miedo innecesariamente de usar punteros sin procesar como parámetros de función. Si la función no va a almacenar el puntero o afectará su vida útil, un puntero sin formato funciona igual de bien y representa el mínimo común denominador. Considere, por ejemplo, cómo pasaría a unique_ptra una función que toma a shared_ptrcomo parámetro, ya sea por valor o por referencia constante.

void DoSomething(myClass * p);

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

Un puntero sin formato como parámetro de función no le impide usar punteros inteligentes en el código de llamada, donde realmente importa.

Sí, la idea completa sobre un shared_ptr <> es que varias instancias pueden contener el mismo puntero sin procesar y la memoria subyacente solo se liberará cuando se destruya la última instancia de shared_ptr <>.

Evitaría un puntero a shared_ptr <> ya que eso anula el propósito, ya que ahora está tratando con raw_pointers nuevamente.

Pasar por valor en su primer ejemplo es seguro, pero hay un modismo mejor. Pase por la referencia constante cuando sea posible; yo diría que sí incluso cuando se trata de punteros inteligentes. Su segundo ejemplo no está exactamente roto pero es muy !???. Tonto, no logra nada y derrota parte del punto de los punteros inteligentes, y te va a dejar en un mundo lleno de errores cuando intentas desreferenciar y modificar las cosas.

en su función DoSomething , está cambiando un miembro de datos de una instancia de clase, myClass por lo que lo que está modificando es el objeto administrado (puntero sin procesar), no el objeto (shared_ptr). Lo que significa que en el punto de retorno de esta función, todos los punteros compartidos al puntero sin procesar administrado verán su miembro de datos: myClass::someFieldcambiado a un valor diferente.

en este caso, está pasando un objeto a una función con la garantía de que no lo está modificando (hablando de shared_ptr, no del objeto de propiedad).

El modismo para expresar esto es a través de: una referencia constante, así

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

Asimismo, le está asegurando al usuario de su función que no está agregando otro propietario a la lista de propietarios del puntero sin procesar. Sin embargo, mantuvo la posibilidad de modificar el objeto subyacente apuntado por el puntero sin formato.

AVISO: Lo que significa que, si de alguna manera alguien llama shared_ptr::resetantes de que usted llame a su función, y en ese momento es el último shared_ptr que posee el raw_ptr, entonces su objeto será destruido y su función manipulará un puntero colgando al objeto destruido. ¡¡¡MUY PELIGROSO!!!