X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9cf33372157f57f74ccf4cd9c839975b24203799..f90913e2ac7938728beed9065f34b7d4c7593513:/include/wx/vector.h diff --git a/include/wx/vector.h b/include/wx/vector.h index 880dd9bbcd..c1a8ece678 100644 --- a/include/wx/vector.h +++ b/include/wx/vector.h @@ -21,6 +21,12 @@ #else // !wxUSE_STL +#include "wx/utils.h" + +#include "wx/beforestd.h" +#include // for placement new +#include "wx/afterstd.h" + template class wxVector { @@ -28,13 +34,14 @@ public: typedef size_t size_type; typedef T value_type; typedef value_type* iterator; + typedef const value_type* const_iterator; typedef value_type& reference; - wxVector() : m_allocsize(16), m_size(0), m_capacity(0), m_objects(0) {} + wxVector() : m_size(0), m_capacity(0), m_values(NULL) {} wxVector(const wxVector& c) { - wxCHECK2(Copy(c), return); + Copy(c); } ~wxVector() @@ -44,19 +51,36 @@ public: void clear() { - for (size_type i = 0; i < size(); i++) - delete m_objects[i]; - free(m_objects); - m_objects = 0; + // call destructors of stored objects: + for ( size_type i = 0; i < m_size; i++ ) + { + m_values[i].~value_type(); + } + + free(m_values); + m_values = NULL; m_size = m_capacity = 0; } void reserve(size_type n) { - if ( !Alloc(n) ) - { - wxFAIL_MSG( _T("out of memory in wxVector::reserve()") ); - } + if ( n <= m_capacity ) + return; + + // increase the size twice, unless we're already too big or unless + // more is requested + // + // NB: casts to size_type are needed to suppress mingw32 warnings about + // mixing enums and ints in the same expression + const size_type increment = m_size > 0 + ? wxMin(m_size, (size_type)ALLOC_MAX_SIZE) + : (size_type)ALLOC_INITIAL_SIZE; + if ( m_capacity + increment > n ) + n = m_capacity + increment; + + m_values = (value_type*)realloc(m_values, n * sizeof(value_type)); + + m_capacity = n; } size_type size() const @@ -76,31 +100,41 @@ public: wxVector& operator=(const wxVector& vb) { - wxCHECK(Copy(vb), *this); + Copy(vb); return *this; } - void push_back(const value_type& o) + void push_back(const value_type& v) { - wxCHECK2(Alloc(size() + 1), return); - Append(new value_type(o)); + reserve(size() + 1); + + // use placement new to initialize new object in preallocated place in + // m_values and store 'v' in it: + void* const place = m_values + m_size; + new(place) value_type(v); + + // only increase m_size if the ctor didn't throw an exception; notice + // that if it _did_ throw, everything is OK, because we only increased + // vector's capacity so far and possibly written some data to + // uninitialized memory at the end of m_values + m_size++; } void pop_back() { - RemoveAt(size() - 1); + erase(end() - 1); } const value_type& at(size_type idx) const { wxASSERT(idx < m_size); - return *m_objects[idx]; + return m_values[idx]; } value_type& at(size_type idx) { wxASSERT(idx < m_size); - return *m_objects[idx]; + return m_values[idx]; } const value_type& operator[](size_type idx) const { return at(idx); } @@ -110,128 +144,123 @@ public: const value_type& back() const { return at(size() - 1); } value_type& back() { return at(size() - 1); } - iterator begin() { return m_objects[0]; } - iterator end() { return m_objects[size()]; } + const_iterator begin() const { return m_values; } + iterator begin() { return m_values; } + const_iterator end() const { return m_values + size(); } + iterator end() { return m_values + size(); } - iterator erase(iterator first, iterator last) - { - size_type idx = first - begin(); - RemoveAt(idx, last - first); - return begin() + idx; - } - iterator erase(iterator it) + iterator insert(iterator it, const value_type& v = value_type()) { - size_type idx = it - begin(); - RemoveAt(idx); - return begin() + idx; - } + // NB: this must be done before reserve(), because reserve() + // invalidates iterators! + const size_t idx = it - begin(); + const size_t after = end() - it; -#if WXWIN_COMPATIBILITY_2_8 - wxDEPRECATED( size_type erase(size_type n) ); -#endif // WXWIN_COMPATIBILITY_2_8 + reserve(size() + 1); - iterator insert(iterator it, const value_type& v = value_type()) - { - wxCHECK2(Alloc(size() + 1), return 0); - size_type idx = it - begin(); - InsertAt(new value_type(v), idx); - return begin() + idx; - } + // unless we're inserting at the end, move following elements out of + // the way: + if ( after > 0 ) + { + memmove(m_values + idx + 1, + m_values + idx, + after * sizeof(value_type)); + } -private: - bool Alloc(size_type sz) - { - // work in multiples of m_allocsize; - sz = (sz / m_allocsize + 1) * m_allocsize; - if (sz <= m_capacity) - return true; +#if wxUSE_EXCEPTIONS + try + { +#endif + // use placement new to initialize new object in preallocated place + // in m_values and store 'v' in it: + void* const place = m_values + idx; + new(place) value_type(v); +#if wxUSE_EXCEPTIONS + } + catch ( ... ) + { + // if the ctor threw an exception, we need to move all the elements + // back to their original positions in m_values + if ( after > 0 ) + { + memmove(m_values + idx, + m_values + idx + 1, + after * sizeof(value_type)); + } + + throw; // rethrow the exception + } +#endif // wxUSE_EXCEPTIONS - // try to realloc - void *mem = realloc(m_objects, sizeof(value_type*) * sz); - if (! mem) - return false; // failed - // success - m_objects = (value_type **) mem; - m_capacity = sz; - return true; + // increment m_size only if ctor didn't throw -- if it did, we'll be + // left with m_values larger than necessary, but number of elements will + // be the same + m_size++; + + return begin() + idx; } - void Append(value_type *obj) + iterator erase(iterator it) { - wxASSERT(m_size < m_capacity); - m_objects[m_size] = obj; - m_size++; + return erase(it, it + 1); } - void InsertAt(size_type idx, value_type *obj) + iterator erase(iterator first, iterator last) { - wxASSERT(idx <= m_size); - wxASSERT(m_size < m_capacity); - if (idx < m_size) - memmove( - m_objects + idx + 1, - m_objects + idx, - ( m_size - idx ) * sizeof(value_type*) ); + if ( first == last ) + return first; + wxASSERT( first < end() && last <= end() ); - m_size++; - } + const size_type idx = first - begin(); + const size_type count = last - first; + const size_type after = end() - last; - void RemoveAt(size_type idx) - { - wxASSERT(idx < m_size); - delete m_objects[idx]; - if (idx < m_size - 1) - memcpy( - m_objects + idx, - m_objects + idx + 1, - ( m_size - idx - 1 ) * sizeof(value_type*) ); - m_size--; - } + // erase elements by calling their destructors: + for ( iterator i = first; i < last; ++i ) + i->~value_type(); + + // once that's done, move following elements over to the freed space: + if ( after > 0 ) + { + memmove(m_values + idx, + m_values + idx + count, + after * sizeof(value_type)); + } - void RemoveAt(size_type idx, size_type count) - { - if (count == 0) - return; - wxASSERT(idx < m_size); - size_type i; - for (i = 0; i < count; i++) - delete m_objects[idx+1]; - if (idx < m_size - count) - memcpy( - m_objects + idx, - m_objects + idx + count, - ( m_size - idx - count ) * sizeof(value_type*) ); m_size -= count; + + return begin() + idx; } - bool Copy(const wxVector& vb) + +#if WXWIN_COMPATIBILITY_2_8 + wxDEPRECATED( size_type erase(size_type n) ); +#endif // WXWIN_COMPATIBILITY_2_8 + +private: + // VC6 can't compile static const int members + enum { ALLOC_INITIAL_SIZE = 16 }; + enum { ALLOC_MAX_SIZE = 4096 }; + + void Copy(const wxVector& vb) { clear(); - if (! Alloc(vb.size())) - return false; - - for (size_type i = 0; i < vb.size(); i++) - { - value_type *o = new value_type(vb.at(i)); - if (! o) - return false; - Append(o); - } + reserve(vb.size()); - return true; + for ( const_iterator i = vb.begin(); i != vb.end(); ++i ) + push_back(*i); } private: - size_type m_allocsize; size_type m_size, m_capacity; - value_type **m_objects; + value_type *m_values; }; #if WXWIN_COMPATIBILITY_2_8 template -typename wxVector::size_type wxVector::erase(size_type n) +inline typename wxVector::size_type wxVector::erase(size_type n) { - RemoveAt(n); + erase(begin() + n); return n; } #endif // WXWIN_COMPATIBILITY_2_8