Depuis C ++ 11, vous devriez le prendre par valeur sur const & plus souvent que vous ne le pensez.
Si vous prenez le std :: shared_ptr (plutôt que le type sous-jacent T), vous le faites parce que vous voulez en faire quelque chose.
Si vous souhaitez le copier quelque part, il est plus logique de le prendre par copie, et std :: le déplacer en interne, plutôt que de le prendre par const & puis de le copier plus tard. Cela est dû au fait que vous autorisez l'appelant à tour à tour std :: déplacer le shared_ptr lors de l'appel de votre fonction, vous économisant ainsi un ensemble d'opérations d'incrémentation et de décrémentation. Ou pas. C'est-à-dire que l'appelant de la fonction peut décider s'il a besoin ou non du std :: shared_ptr après avoir appelé la fonction, et selon qu'il se déplace ou non. Ce n'est pas réalisable si vous passez par const &, et c'est donc de préférence de le prendre en valeur.
Bien sûr, si l'appelant a besoin de son shared_ptr plus longtemps (donc ne peut pas std :: le déplacer) et que vous ne voulez pas créer une copie simple dans la fonction (par exemple, vous voulez un pointeur faible, ou vous ne voulez que parfois pour le copier, selon certaines conditions), alors un const & peut être préférable.
Par exemple, vous devez faire
void enqueue(std::shared<T> t) m_internal_queue.enqueue(std::move(t));
plus de
void enqueue(std::shared<T> const& t) m_internal_queue.enqueue(t);
Parce que dans ce cas, vous créez toujours une copie en interne
shared_ptr
, et je peux le changer si je veux.», Tandis que la version de valeur dit «Je vais copier votreshared_ptr
, donc pendant que je peux le changer, vous ne le saurez jamais. ) Un paramètre const-reference est la vraie solution, qui dit "Je vais en alias certainsshared_ptr
, et je promets de ne pas le changer." (Ce qui est extrêmement similaire à la sémantique par valeur!)