Comment stocker des objets sans copier ou déplacer le constructeur dans std:: vector?

pour résumer ce qui a été proposé jusqu'à présent:

1. Use vector<unique_ptr<T>> -- ajoute un niveau explicite d'indirectement et a été non désirée par OP.
2. utiliser deque<T> -- j'ai d'abord essayé deque , mais effacer des objets de celui-ci ne fonctionne pas non plus. voir cette discussion sur les différences entre deque et list .

la solution est d'utiliser forward_list qui est une liste liée individuellement (ou vous pouvez utiliser list si vous voulez une liste à double liaison). Comme @JanHudec l'a souligné, vector (et beaucoup de ses amis) nécessite une réattribution lors de l'ajout ou de la suppression d'articles. Cela ne convient pas aux objets comme mutex et atomic qui ne sont pas autorisés à être copiés ou déplacés. forward_list et list n'exigent pas que parce que chaque cellule est attribuée indépendamment (Je ne peux pas citer la norme, mais l'indexation méthode donne lieu à cette hypothèse). Comme il s'agit en fait de listes liées, elles ne prennent pas en charge l'indexation par accès aléatoire. myList.begin() + i vous obtiendra un itérateur du i 'e élément, mais il (très certainement) aura à boucle à travers toutes les précédentes i cellules d'abord.

Je n'ai pas regardé les promesses du standard, mais les choses fonctionnent bien sur Windows (Visual Studio) et CompileOnline (g++). Hésitez pas à jouer avec le cas d'essai suivant sur CompileOnline :

#include <forward_list>
#include <iostream>
#include <mutex>
#include <algorithm>

using namespace std;

class X
{
    /// Private copy constructor.
    X(const X&);
    /// Private assignment operator.
    X& operator=(const X&);

public:
    /// Some integer value
    int val;
    /// An object that can be neither copied nor moved
    mutex m;

    X(int val) : val(val) { }
};


int main()
{
    // create list
    forward_list<X> xList;

    // add some items to list
    for (int i = 0; i < 4; ++i)
       xList.emplace_front(i);

    // print items
    for (auto& x : xList)
       cout << x.val << endl;

    // remove element with val == 1    
    // WARNING: Must not use remove here (see explanation below)
    xList.remove_if([](const X& x) { return x.val == 1; });


    cout << endl << "Removed '1'..." << endl << endl;

    for (auto& x : xList)
       cout << x.val << endl;

   return 0;
}

sortie:

Executing the program....
$demo 
3
2
1
0

Removed '1'...

3
2
0

je m'attends à peu près avoir le même rendement que vector<unique_ptr<T>> (tant que vous n'utilisez pas d'accès aléatoire indexation trop souvent).

WARNING : L'utilisation de forward_list::remove ne fonctionne pas actuellement dans VS 2012. C'est parce qu'elle copie l'élément avant d'essayer de les supprimer il. Le fichier d'en-tête Microsoft Visual Studio 11.0\VC\include\forward_list (même problème dans list ) révèle:

void remove(const _Ty& _Val_arg)
{   // erase each element matching _Val
    const _Ty _Val = _Val_arg;  // in case it's removed along the way

    // ...
}

ainsi, il est copié "au cas où il est enlevé en cours de route". Cela signifie que list et forward_list ne permettent même pas de stocker unique_ptr . Je suppose que c'est un bogue du design.

la solution est simple: vous devez utiliser remove_if au lieu de remove parce que la mise en œuvre de cette fonction ne copie rien.

une grande partie du crédit va aux autres réponses. Cependant, comme aucune d'entre elles n'était une solution complète sans pointeurs, j'ai décidé d'écrire cette réponse.