Quelle est la surcharge des pointeurs intelligents par rapport aux pointeurs normaux en C ++ 11? En d'autres termes, mon code sera-t-il plus lent si j'utilise des pointeurs intelligents, et si oui, combien plus lent?
Plus précisément, je pose des questions sur le C ++ 11 std::shared_ptr
et std::unique_ptr
.
De toute évidence, les éléments poussés vers le bas de la pile seront plus grands (du moins je le pense), car un pointeur intelligent doit également stocker son état interne (nombre de références, etc.), la question est vraiment de savoir combien cela va-t-il affecter mes performances, voire pas du tout?
Par exemple, je renvoie un pointeur intelligent à partir d'une fonction au lieu d'un pointeur normal:
std::shared_ptr<const Value> getValue();
// versus
const Value *getValue();
Ou, par exemple, lorsqu'une de mes fonctions accepte un pointeur intelligent comme paramètre au lieu d'un pointeur normal:
void setValue(std::shared_ptr<const Value> val);
// versus
void setValue(const Value *val);