Dois-je utiliser C++11 emplace_back avec des pointeurs containters?

Avoir une Base habituelle -> Dérivés de la hiérarchie, comme:

class Fruit { ... };
class Pear : Fruit { ... };
class Tomato : Fruit { ... };

std::vector<Fruit*> m_fruits;

A sens (e.g: il a une meilleure performance) à utiliser emplace_back au lieu de push_back?

std::vector::emplace_back( new Pear() );
std::vector::emplace_back( new Tomato() );
vous ne saurez pas jusqu'à ce que vous référence/profil
Utilisation std::vector<std::unique_ptr<Fruit>> pour éviter les fuites de mémoire, alors la réponse est évidente.
J'lecteur que emplace_back construit lui-même l'objet, mais dans le cas des pointeurs, je n'ai pas la moindre idée de si il ont un sens.

OriginalL'auteur Zhen | 2013-04-03

  1. 9

    Les pointeurs sont des types scalaires et donc littérale types, et ainsi de copier, déplacer et emplace construction (à partir d'une lvalue ou rvalue) sont l'équivalent, et généralement de compiler un code identique (un scalaire copie). push_back est plus clair que vous effectuez un scalaire copie, alors que emplace_back devrait être réservé pour les emplace la construction de l'appel d'une non-copiez ou déplacez - le constructeur (par exemple, une conversion ou multi-argument du constructeur).

    Si votre vecteur doit tenir std::unique_ptr<Fruit> au lieu de raw pointeurs (pour éviter les fuites de mémoire), puis parce que vous êtes à l'appel d'une conversion constructeur emplace_back serait plus correct. Cependant, que peut encore la fuite si l'on prolonge le vecteur d'échec, donc, dans ce cas, vous devez utiliser push_back(make_unique<Pear>()) etc.

    make_unique n'est pas dans la norme, et il semble que emplace_back est la même que push_back( std::move( X ) ) [je suis en utilisant gcc 4.7]
    Il peut sembler de cette façon, mais il ne l'est pas. emplace_back(new T()) pouvez fuite, alors que les push_back(make_unique<T>()) ne peut pas. Et oui, make_unique manque de contrôle, vous pouvez trouver des applications sur le web.
    std::make_unique() a été ajouté en C++14.

    OriginalL'auteur ecatmur

  2. 16

    Ne pas utiliser des pointeurs, l'utilisation std::unique_ptr comme ceci:

    std::vector<std::unique_ptr<Fruit>> m_fruits;

    Et que vous ne pouvez pas copier la construction d'un std::unique_ptr vous devez utiliser emplace_back (bien que vous pouvez utiliser push_back avec std::move).

    m_fruits.emplace_back(nouvelle Poire()); 
m_fruits.emplace_back(nouveau Tomate());

    Edit:

    Tel qu'il apparaît que l'utilisation de std::vector<std::unique_ptr<T>>::emplace_back et new fuites peuvent se produire si le std::vector besoins et ne parvient pas à réallouer la mémoire, l'approche que je recommande (jusqu'à ce que le C++14 introduit std::make_unique) est d'utiliser push_back comme ceci:

    m_fruits.push_back(std::unique_ptr<Fruit>(new Pear));
m_fruits.push_back(std::unique_ptr<Fruit>(new Tomato));

    Ou à l'aide de std::make_unique:

    m_fruits.push_back(std::make_unique<Pear>());
m_fruits.push_back(std::make_unique<Tomato>());

    OriginalL'auteur Snps