StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>The initialization of the elements allocated is controlled by the Allocator template argument, if you need it customized, customize it. But remember that this can get easily wind-up in the realm of dirty hacking, so use with caution. For instance, here is a pretty dirty solution. It will avoid the initialization, but it most probably will be worse in performance, but for demonstration's sake (as people have said this is impossible!... impossible is not in a C++ programmer's vocabulary!): </p> <pre><code>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) } </code></pre> <p>Of course, the above is awkward and not recommended, and certainly won't be any better than actually letting the memory get filled with copies of the first element (especially since the use of this flag-checking will impede on each element-construction). But it is an avenue to explore when looking to optimize the allocation and initialization of elements in an STL container, so I wanted to show it. The point is that the only place you can inject code that will stop the std::vector container from calling the copy-constructor to initialize your elements is in the construct function of the vector's allocator object.</p> <p>Also, you could do away with the "switch" and simply do a "no-init-allocator", but then, you also turn off copy-construction which is needed to copy the data during resizing (which would make this vector class much less useful). </p>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload