Как я могу избежать инициализации всех элементов std :: vector ‹›?

Инициализация выделенных элементов контролируется аргументом шаблона Allocator, если он вам нужен, настройте его. Но помните, что это может легко оказаться грязным взломом, поэтому используйте его с осторожностью. Например, вот довольно грязное решение. Это позволит избежать инициализации, но, скорее всего, будет хуже по производительности, но для демонстрации (как люди сказали, что это невозможно! ... Невозможно не входит в словарь программиста C ++!):

template <typename T>
class switch_init_allocator : public std::allocator< T > {
  private:
    bool* should_init;
  public:
    template <typename U>
    struct rebind {
      typedef switch_init_allocator<U> other;
    };

    //provide the required no-throw constructors / destructors:
    switch_init_allocator(bool* aShouldInit = NULL) throw() : std::allocator<T>(), should_init(aShouldInit) { };
    switch_init_allocator(const switch_init_allocator<T>& rhs) throw() : std::allocator<T>(rhs), should_init(rhs.should_init) { };
    template <typename U>
    switch_init_allocator(const switch_init_allocator<U>& rhs, bool* aShouldInit = NULL) throw() : std::allocator<T>(rhs), should_init(aShouldInit) { };
    ~switch_init_allocator() throw() { };

    //import the required typedefs:
    typedef typename std::allocator<T>::value_type value_type;
    typedef typename std::allocator<T>::pointer pointer;
    typedef typename std::allocator<T>::reference reference;
    typedef typename std::allocator<T>::const_pointer const_pointer;
    typedef typename std::allocator<T>::const_reference const_reference;
    typedef typename std::allocator<T>::size_type size_type;
    typedef typename std::allocator<T>::difference_type difference_type;

    //redefine the construct function (hiding the base-class version):
    void construct( pointer p, const_reference cr) {
      if((should_init) && (*should_init))
        new ((void*)p) T ( cr );
      //else, do nothing.
    };
};

template <typename T>
class my_vector : public std::vector<T, switch_init_allocator<T> > {
  public:
    typedef std::vector<T, switch_init_allocator<T> > base_type;
    typedef switch_init_allocator<T> allocator_type;
    typedef std::vector<T, allocator_type > vector_type;
    typedef typename base_type::size_type size_type;
  private:
    bool switch_flag; //the order here is very important!!
    vector_type vec;
  public:  
    my_vector(size_type aCount) : switch_flag(false), vec(aCount, allocator_type(&switch_flag)) { };
    //... and the rest of this wrapper class...
    vector_type& get_vector() { return vec; };
    const vector_type& get_vector() const { return vec; };
    void set_switch(bool value) { switch_flag = value; };
};

class xyz{};

int main(){
  my_vector<xyz> v(1024); //this won't initialize the memory at all.
  v.set_switch(true); //set back to true to turn initialization back on (needed for resizing and such)
}

Конечно, вышеизложенное неудобно и не рекомендуется, и, конечно же, не будет лучше, чем фактически позволить памяти заполниться копиями первого элемента (тем более, что использование этой проверки флагов будет препятствовать построению каждого элемента) . Но это путь, который нужно изучить при поиске оптимизации распределения и инициализации элементов в контейнере STL, поэтому я хотел показать его. Дело в том, что единственное место, где вы можете ввести код, который остановит контейнер std :: vector от вызова конструктора копирования для инициализации ваших элементов, - это функция построения объекта распределителя вектора.

Кроме того, вы можете отказаться от «переключателя» и просто выполнить «no-init-allocator», но затем вы также отключите копирующую конструкцию, которая необходима для копирования данных во время изменения размера (что сделало бы этот векторный класс очень менее полезно).

Это странный уголок vector. Проблема заключается в не того, что ваш элемент инициализируется значением ... а в том, что случайное содержимое первого прототипного элемента копируется во все остальные элементы вектора. (Это поведение изменилось в C ++ 11, значение которого инициализирует каждый элемент).

Это (/ было) сделано по уважительной причине: рассмотрите некоторый объект с подсчетом ссылок ... если вы создаете vector, запрашивающий 1000 элементов, инициализированных для такого объекта, вам, очевидно, нужен один объект со счетчиком ссылок 1000, вместо того, чтобы иметь 1000 независимых «клонов». Я говорю «очевидно», потому что подсчет ссылок на объект в первую очередь подразумевает, что это очень желательно.

В любом случае, тебе почти не повезло. Фактически vector гарантирует, что все элементы одинаковы, даже если контент, с которым он синхронизируется, оказывается неинициализированным мусором.

В стране нестандартного хэппи-хакинга, специфичного для g ++, мы можем использовать любую общедоступную шаблонную функцию-член в интерфейсе vector в качестве бэкдора для изменения частных данных-членов, просто специализируя шаблон для некоторого нового типа.

ПРЕДУПРЕЖДЕНИЕ: не только для этого «решения», но и для всей этой попытки избежать построения по умолчанию ... не делайте этого для типов с важными инвариантами - вы нарушите инкапсуляцию и может легко иметь vector или некоторую операцию, которую вы пытаетесь вызвать operator=(), конструкторы копирования и / или деструкторы, где *this / левая и / или правая аргументы не учитывают эти инварианты. Например, избегайте типов значений с указателями, которые, как вы ожидаете, будут NULL, или на допустимые объекты, счетчики ссылок, дескрипторы ресурсов и т. Д.

#include <iostream>
#include <vector>

struct Uninitialised_Resize
{
    explicit Uninitialised_Resize(int n) : n_(n) { }
    explicit Uninitialised_Resize() { }
    int n_;
};

namespace std
{
    template <>
    template <>
    void vector<int>::assign(Uninitialised_Resize ur, Uninitialised_Resize)
    {
        this->_M_impl._M_finish = this->_M_impl._M_start + ur.n_;

        // note: a simpler alternative (doesn't need "n_") is to set...
        //   this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
        // ...which means size() will become capacity(), which may be more
        // you reserved() (due to rounding; good) or have data for
        // (bad if you have to track in-use elements elsewhere,
        //  which makes the situation equivalent to just reserve()),
        // but if you can somehow use the extra elements then all's good.
    }
}

int main()
{
    {
        // try to get some non-0 values on heap ready for recycling...
        std::vector<int> x(10000);
        for (int i = 0; i < x.size(); ++i)
            x[i] = i;
    }

    std::vector<int> x;
    x.reserve(10000);
    for (int i = 1; i < x.capacity(); ++i)
        if (x[0] != x[i])
        {
            std::cout << "lucky\n";
            break;
        }
    x.assign(Uninitialised_Resize(1000), Uninitialised_Resize());

    for (int i = 1; i < x.size(); ++i)
        if (x[0] != x[i])
        {
            std::cout << "success [0] " << x[0] << " != [" << i << "] "
                << x[i] << '\n';
            break;
        }
}

Мой вывод:

lucky
success [0] 0 != [1] 1

Это говорит о том, что новый vector был перераспределен в куче, которую первый вектор освободил, когда он вышел за пределы области видимости, и показывает, что значения не затираются назначением. Конечно, невозможно узнать, были ли признаны недействительными некоторые другие важные инварианты класса, не проверив очень внимательно vector источники, а точные имена / импорт частных членов могут измениться в любое время ...

Вы оборачиваете все свои примитивы в структуру:

struct IntStruct
{
    IntStruct();

    int myInt;
}

с IntStruct (), определенным как пустой конструктор. Таким образом, вы объявляете v как IntStruct v;, поэтому, когда vector из xyzs all value-initialize, все, что они делают, это инициализируют значение v, что не работает.

РЕДАКТИРОВАТЬ: Я неправильно понял вопрос. Это то, что вам следует делать, если у вас есть vector примитивных типов, потому что vector определен для инициализации значения при создании элементов с помощью метода resize(). Структуры не обязаны инициализировать значения своих членов при построении, хотя эти «неинициализированные» значения все равно могут быть установлены в 0 с помощью чего-то еще - эй, они могут быть чем угодно.

Я не вижу, чтобы память была инициализирована. Конструктор int() по умолчанию ничего не делает, как и в C.

Программа:

#include <iostream>
#include <vector>

struct xyz {
    xyz() {}
    xyz(const xyz& o): v(o.v) {} 
    xyz& operator=(const xyz& o) { v=o.v; return *this; }
    int v;
};

std::vector<xyz> test() {
    return std::vector<xyz>(1024);
}

int main()
{
    std::vector<xyz> foo = test();
    for(int i = 0; i < 10; ++i)
    {
        std::cout << i << ": " << foo[i].v << std::endl;
    }
    return 0;
}

Вывод:

$ g++ -o foo foo.cc
$ ./foo 
0: 1606418432
1: 1606418432
2: 1606418432
3: 1606418432
4: 1606418432
5: 1606418432
6: 1606418432
7: 1606418432
8: 1606418432
9: 1606418432

РЕДАКТИРОВАТЬ:

Если вы просто пытаетесь инициализировать вектор какой-то нетривиальной вещью и не хотите тратить время на построение его содержимого по умолчанию, вы можете попробовать создать собственный итератор и передать его конструктору вектора.

Измененный пример:

#include <iostream>
#include <vector>
#include <iterator>

struct xyz {
    xyz() {}
    xyz(int init): v(init) {}
    xyz(const xyz& o): v(o.v) {} 
    xyz& operator=(const xyz& o) { v=o.v; return *this; }
    int v;
};

class XYZInitIterator: public std::iterator<std::input_iterator_tag, xyz>
{
public:
                        XYZInitIterator(int init): count(init) {}
                        XYZInitIterator(const XYZInitIterator& iter)
                        : count(iter.count) {}
    XYZInitIterator&    operator=(const XYZInitIterator& iter)
                        { count = iter.count; return *this; }
    value_type          operator*() const { return xyz(count); }
    bool                operator==(const XYZInitIterator& other) const 
                        { return count == other.count; }
    bool                operator!=(const XYZInitIterator& other) const 
                        { return count != other.count; }
    value_type          operator++() { return xyz(++count); }
    value_type          operator++(int) { return xyz(count++); }
private:
    int count;
};

std::vector<xyz> test() {
    XYZInitIterator start(0), end(1024);
    return std::vector<xyz>(start, end);
}

int main()
{
    std::vector<xyz> foo = test();
    for(int i = 0; i < 10; ++i)
    {
        std::cout << std::dec << i << ": " << std::hex << foo[i].v << std::endl;
    }
    return 0;
}

Вывод:

$ g++ -o foo foo.cc
$ ./foo 
0: 0
1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9

Для справки, следующий код приводит к оптимальной сборке в g ++: Я не говорю, что когда-либо буду его использовать, и не призываю вас к этому. Это не настоящий C ++! Это очень, очень грязный хак! Я думаю, это может даже зависеть от версии g ++, так что не используйте его. Меня бы стошнило, если бы я увидел, что его где-то использовали.

#include <vector>

template<typename T>
static T create_uninitialized(size_t size, size_t capacity) {
    T v;
#if defined(__GNUC__)
    // Don't say it. I know -_-;
    // Oddly, _M_impl is public in _Vector_base !?
    typedef typename T::value_type     value_type;
    typedef typename T::allocator_type allocator_type;
    typedef std::_Vector_base<value_type, allocator_type> base_type;
    base_type& xb(reinterpret_cast<base_type&>(v));
    value_type* p(new value_type[capacity]);
#if !defined(__EXCEPTIONS)
    size=p?size:0;         // size=0 if p is null
    capacity=p?capacity:0; // capacity=0 if p is null
#endif
    capacity=std::max(size, capacity); // ensure size<=capacity
    xb._M_impl._M_start = p;
    xb._M_impl._M_finish = p+size;
    xb._M_impl._M_end_of_storage = p+capacity;
#else
    // Fallback, for the other compilers
    capacity=std::max(size, capacity);
    v.reserve(capacity);
    v.resize(size);
#endif
    return v;
}

struct xyz {
    // empty default constructor
    xyz() { }
    xyz(const xyz& o): v(o.v) { }
    xyz& operator=(const xyz& o) { v=o.v; return *this; }
    int v;
    typedef std::vector<xyz> vector;
};

// test functions for assembly dump
extern xyz::vector xyz_create() {
    // Create an uninitialized vector of 12 elements, with
    // a capacity to hold 256 elements.
    return create_uninitialized<xyz::vector>(12,256);
}

extern void xyz_fill(xyz::vector& x) {
    // Assign some values for testing
    for (int i(0); i<x.size(); ++i) x[i].v = i;
}

// test
#include <iostream>
int main() {
    xyz::vector x(xyz_create());
    xyz_fill(x);
    // Dump the vector
    for (int i(0); i<x.size(); ++i) std::cerr << x[i].v << "\n";
    return 0;
}

РЕДАКТИРОВАТЬ: понял, что _Vector_impl был общедоступным, что упрощает ситуацию.

РЕДАКТИРОВАТЬ: вот сгенерированная сборка ARM для xyz_create (), скомпилированная с -fno-exceptions (разобранная с помощью c ++ filter) и без какого-либо цикла инициализации памяти:

xyz_create():
    mov r3, #0
    stmfd   sp!, {r4, lr}
    mov r4, r0
    str r3, [r0, #0]
    str r3, [r0, #4]
    str r3, [r0, #8]
    mov r0, #1024
    bl  operator new[](unsigned long)(PLT)
    cmp r0, #0
    moveq   r3, r0
    movne   r3, #1024
    moveq   r2, r0
    movne   r2, #48
    add r2, r0, r2
    add r3, r0, r3
    stmia   r4, {r0, r2, r3}    @ phole stm
    mov r0, r4
    ldmfd   sp!, {r4, pc}

..а здесь для x86_64:

xyz_create():
    pushq   %rbp
    movq    %rsp, %rbp
    pushq   %rbx
    movq    %rdi, %rbx
    subq    $8, %rsp
    movq    $0, (%rdi)
    movq    $0, 8(%rdi)
    movq    $0, 16(%rdi)
    movl    $1024, %edi
    call    operator new[](unsigned long)
    cmpq    $1, %rax
    movq    %rax, (%rbx)
    sbbq    %rdx, %rdx
    notq    %rdx
    andl    $1024, %edx
    cmpq    $1, %rax
    sbbq    %rcx, %rcx
    leaq    (%rax,%rdx), %rdx
    notq    %rcx
    andl    $48, %ecx
    movq    %rdx, 16(%rbx)
    leaq    (%rax,%rcx), %rcx
    movq    %rbx, %rax
    movq    %rcx, 8(%rbx)
    addq    $8, %rsp
    popq    %rbx
    leave
    ret

Вы не можете избежать инициализации элементов std :: vector.

По этой причине я использую производный класс std :: vector. resize() реализован в этом примере. Вы также должны реализовать конструкторы.

Хотя это не стандартный C ++, а реализация компилятора :-(

#include <vector>

template<typename _Tp, typename _Alloc = std::allocator<_Tp>>
class uvector : public std::vector<_Tp, _Alloc>
{
    typedef std::vector<_Tp, _Alloc> parent;
    using parent::_M_impl;

public:
    using parent::capacity;
    using parent::reserve;
    using parent::size;
    using typename parent::size_type;

    void resize(size_type sz)
    {
        if (sz <= size())
            parent::resize(sz);
        else
        {
            if (sz > capacity()) reserve(sz);
            _M_impl._M_finish = _M_impl._M_start + sz;
        }
    }
};

Мне тоже любопытно. Вы просто хотите, чтобы память была инициализирована случайным образом?

Элементы вектора хранятся в последовательных ячейках памяти, поэтому возможна случайная инициализация.

Если вам нужен вектор с зарезервированной только памятью, но без инициализированных элементов, используйте reserve вместо конструктора:

std::vector<xyz> v;
v.reserve(1024);
assert(v.capacity() >= 1024);
assert(v.size() == 0);

В связи с тем, как ваш struct объявлен на данный момент, не существует механизма для инициализации по умолчанию члена int вашей структуры, поэтому вы получаете поведение C по умолчанию, которое является неопределенной инициализацией. Чтобы инициализировать переменную-член int со значением инициализации по умолчанию, вам нужно будет добавить его в список инициализации конструктора структуры. Например,

struct xyz {
    xyz(): v() { } //initialization list sets the value of int v to 0
    int v;
};

В то время как

struct xyz {
    xyz(): { } //no initialization list, therefore 'v' remains uninitialized
    int v;
};