Redimensionnement D'un c++ std::vecteur sans initialisation des données [dupliquer]

vector<char> buf;
buf.reserve(N);
int M = read(fd, &buf[0], N);

ce fragment de code invoque un comportement non défini. Vous ne pouvez pas écrire au-delà de size() elements, même si vous avez réservé l'espace .

le code correct est comme:

vector<char> buf;
buf.resize(N);
int M = read(fd, &buf[0], N);
buf.resize(M);

---

PS. votre déclaration "avec des vecteurs, on peut supposer que les éléments sont stockés de façon contiguë dans la mémoire, permettant la gamme [&vec[0], &vec[vec.capacity()) pour être utilisé comme un tableau normal" n'est pas vrai. La plage admissible est [&vec[0], &vec[vec.size()) .

on dirait que vous pouvez faire ce que vous voulez en C++11 (bien que je n'ai pas essayé cela moi-même). Vous devrez définir un allocateur personnalisé pour le vecteur, puis utiliser emplace_back() .

d'abord, définir

struct do_not_initialize_tag {};

puis définissez votre allocator avec cette fonction de membre:

class my_allocator {
    void construct(char* c, do_not_initialize_tag) const {
        // do nothing
    }

    // details omitted
    // ...
}

maintenant vous pouvez ajouter des éléments à votre tableau sans les initialiser:

std::vector<char, my_allocator> buf;
buf.reserve(N);
for (int i = 0; i != N; ++i)
    buf.emplace_back(do_not_initialize_tag());
int M = read(fd, buf.data(), N);
buf.resize(M);

l'efficacité de ceci dépend sur le compilateur optimiseur. Par exemple, la boucle peut augmenter la taille de la variable membre N fois.

écrit dans et après l'élément size() th est un comportement non défini.

exemple suivant copie un fichier entier dans un vecteur de manière c++ (pas besoin de connaître la taille du fichier et pas besoin de préallouer la mémoire dans le vecteur):

#include <algorithm>
#include <fstream>
#include <iterator>
#include <vector>

int main()
{
    typedef std::istream_iterator<char> istream_iterator;
    std::ifstream file("example.txt");
    std::vector<char> input;

    file >> std::noskipws;
    std::copy( istream_iterator(file), 
               istream_iterator(),
               std::back_inserter(input));
}

un autre, plus récent, question, un duplicata de celui-ci , a une réponse , qui ressemble exactement à ce qui est demandé ici. Voici sa copie (de v3) pour consultation rapide:

C'est un problème connu que l'initialisation ne peut pas être désactivé, même explicitement pour std::vector .

les gens mettent normalement en œuvre leur propre pod_vector<> qui ne fait pas toute initialisation des éléments.

une autre façon est de créer un type qui est layout-compatible avec char, dont le constructeur ne fait rien:

struct NoInitChar
{
    char value;
    NoInitChar() {
        // do nothing
        static_assert(sizeof *this == sizeof value, "invalid size");
        static_assert(__alignof *this == __alignof value, "invalid alignment");
    }
};

int main() {
    std::vector<NoInitChar> v;
    v.resize(10); // calls NoInitChar() which does not initialize

    // Look ma, no reinterpret_cast<>!
    char* beg = &v.front().value;
    char* end = beg + v.size();
}

votre fragment de programme est entré dans le domaine du comportement non défini.

quand buf.empty() est vrai, buf[0] a un comportement non défini, et donc &buf[0] est également Non défini.

ce fragment fait probablement ce que vous voulez.

vector<char> buf;
buf.resize(N); // preallocate space
int M = read(fd, &buf[0], N);
buf.resize(M); // disallow access to the remainder

vous pourriez vouloir essayer de sous-classe la classe vectorielle et mettre en œuvre une méthode qui définit la taille en accédant directement aux variables membres: dans GNU C++ ceci est fait en suivant le fragment de code:

template <typename T, typename A = mmap_allocator<T> >
class mmappable_vector: public std::vector<T, A> {
public:
    void map_into_memory(const size_t n)
    {
        std::vector<T,A>::reserve(n);
#ifdef __GNUC__
        std::vector<T,A>::_M_impl._M_finish = std::vector<T,A>::_M_impl._M_end_of_storage;
#else
#error "Not GNU C++, please either implement me or use GCC"
#endif
    }
};

et utilisez cette classe (vous devrez ajouter quelques constructeurs) au lieu de stl::vector. Cependant, à moins que vous ne manipuliez des fichiers de plus de 1 Go, cela n'en vaut pas la peine.

Si vous le faites, vous voudrez peut-être donner le mmap_allocator d'essayer (encore beta, disponible à partir de github.com/johannesthoma/mmap_allocator).