erreur: implicitement supprimée car la définition par défaut serait mal formée (vecteur de structures)

Comme 0x499602d2 correctement souligné, fill besoin de copier-assigner à partir de la troisième argument. Que votre type est implicitement noncopyable, vous ne pouvez pas utiliser fill.

Vous pouvez, cependant, utiliser generate pour remplir votre vecteur:

#include <vector>
#include <algorithm>

struct noncopyable
{
    noncopyable() = default;

    //make it noncopyable
    noncopyable(noncopyable const&) = delete;
    noncopyable& operator=(noncopyable const&) = delete;

    //make it movable (thanks, gx_)
    noncopyable(noncopyable&&) = default;
    noncopyable& operator=(noncopyable&&) = default;
};

int main()
{
    std::vector<noncopyable> vec(10);
    std::generate(begin(vec), end(vec), []()->noncopyable{return {};});
}

Remarque: cela ne fonctionne que si noncopyable a un non supprimés, accessible constructeur de déplacement. Cependant, si il ne pas avoir une telle ctor, vous ne serez pas en mesure d'utiliser une grande partie du vecteur (resize nécessite MoveInsertablece qui nécessite soit une copie ou déplacez-ctor).

G++4.8, à utiliser generatevous aurez besoin d'une fonction libre. Je pense que c'est un bug.

#include <vector>
#include <algorithm>

struct noncopyable
{
    noncopyable() = default;
    noncopyable(noncopyable const&) = delete;
};

noncopyable free_func()
{  return {};  }

int main()
{
    std::vector<noncopyable> vec;
    std::generate(begin(vec), end(vec), free_func);
}

Encore une autre question est de savoir si vous pouvez initialiser votre vecteur comme ça. Je dirais que NON. fill et generate ne pas construire éléments, mais les écraser (attribuer). Qui est, vous aurez déjà besoin d'avoir un vecteur avec plusieurs éléments avant de pouvoir les utiliser.

La meilleure version de initialiser un vecteur à N par défaut-les éléments construits est d'utiliser le constructeur:

std::vector<noncopyable> vec(10);

Crée un vector avec 10 par défaut-les éléments construits. La seule exigence est que noncopyable est DefaultConstructible (essentiellement, il doit avoir un constructeur par défaut).

Si votre type est noncopyable ET nonmovable, vous ne pouvez pas l'utiliser directement (ou un membre de données) afin de le stocker à l'intérieur d'un vector(*). Afin de rendre une classe C mobile, qui contient un noncopyable, nonmovable type Xvous avez besoin de stocker X comme un pointeur:

_{(*) eh Bien, vous pouvez, mais vous ne pouvez pas redimensionner le vecteur, vous ne pouvez pas insérer etc.}

struct nocopies_nomoves
{
    nocopies_nomoves() = default;

    nocopies_nomoves(nocopies_nomoves const&) = delete;
    nocopies_nomoves& operator=(nocopies_nomoves const&) = delete;

    //not required to be explicitly deleted:
    nocopies_nomoves(nocopies_nomoves&&) = delete;
    nocopies_nomoves& operator=(nocopies_nomoves&&) = delete;
};

#include <utility>
#include <memory>
class C
{
public:
    C() : ptr( new nocopies_nomoves() ) {} //make_unique in C++1y

    //I don't think you need to explicitly define those as defaulted;
    //at least not if you don't declare ANY of the copy/move ctors, assignment ops
    //and dtor
    C(C&& rhs) = default;
    C& operator=(C&& rhs) = default;
    ~C() = default;

    //not required to be explicitly deleted:
    C(C const&) = delete;
    C& operator=(C const&) = delete;
private:
    std::unique_ptr<nocopies_nomoves> ptr;
};

Maintenant, vous pouvez créer un vector<C> et de l'utiliser (par exemple resizeinsert...)

#include <vector>
#include <algorithm>

static C generate_C()
{
    return {};
}

int main()
{
    std::vector<C> vec(10);
    //note: futile statement below; overwrites the 10 default-constructed
    //      elements
    std::generate(begin(vec), end(vec), generate_C);
}