Post by aslanIt doesn't create any problem with the VC6 and runs OK. Yes it's
weird but believe it or not, memset doesn't write any random memory.
How do you determine that?
*** aslan *** Using debugger's memory window (I'm talking about VC++6).
Well, this way you see that some memory is being written to. How do you know
that this memory is actually properly allocated and owned by the vector
object? After all, if you just take an uninitialized pointer and memset to
it, then the memory window will show that the memory pointed to by this
pointer is in fact initialized - but that doesn't make the program valid.
*** aslan ***
OK it's a wrong way. I should't have used std::vector<bool> there. I am only
answering your question "how do you know..." :
By stepping into the reserve() function which ends up by calling malloc with
the specified size. So you have one big chunk of memory on which you can
call resize() as many times as possible without any reallocation occurring
provided that you don't resize() with a bigger size than reserve() has
already allocated.
static void* allocate(size_t __n)
{
void* __result = malloc(__n);
if (0 == __result) __result = _S_oom_malloc(__n);
return __result;
}
--- which is called by_Alloc::allocate(size_t __n)
/* __n must be > 0 */
static void* allocate(size_t __n)
{
void* __ret = 0;
if (__n > (size_t) _MAX_BYTES) {
__ret = malloc_alloc::allocate(__n);
}
else {
_Obj* __STL_VOLATILE* __my_free_list
= _S_free_list + _S_freelist_index(__n);
// Acquire the lock here with a constructor call.
// This ensures that it is released in exit or during stack
// unwinding.
# ifndef _NOTHREADS
/*REFERENCED*/
_Lock __lock_instance;
# endif
_Obj* __RESTRICT __result = *__my_free_list;
if (__result == 0)
__ret = _S_refill(_S_round_up(__n));
else {
*__my_free_list = __result -> _M_free_list_link;
__ret = __result;
}
}
return __ret;
};
--- which is called by alloc::allocate(size_t __n)
template<class _Tp, class _Alloc>
class simple_alloc {
public:
static _Tp* allocate(size_t __n)
{ return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
static _Tp* allocate(void)
{ return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
static void deallocate(_Tp* __p, size_t __n)
{ if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
static void deallocate(_Tp* __p)
{ _Alloc::deallocate(__p, sizeof (_Tp)); }
};
--- which is called by _Vector_base::_M_allocate(size_t __n)
_Tp* _M_allocate(size_t __n)
{ return _M_data_allocator::allocate(__n); }
--- which is called by_Vector_base::_M_allocate_and_copy
iterator _M_allocate_and_copy(size_type __n, const_iterator __first,
const_iterator __last)
{
iterator __result = _M_allocate(__n);
__STL_TRY {
uninitialized_copy(__first, __last, __result);
return __result;
}
__STL_UNWIND(_M_deallocate(__result, __n));
}
--- which is called by_Vector_base::reserve(size_type __n)
void reserve(size_type __n) {
if (capacity() < __n) {
const size_type __old_size = size();
iterator __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish);
destroy(_M_start, _M_finish);
_M_deallocate(_M_start, _M_end_of_storage - _M_start);
_M_start = __tmp;
_M_finish = __tmp + __old_size;
_M_end_of_storage = _M_start + __n;
}
}
--
With best wishes,
Igor Tandetnik
With sufficient thrust, pigs fly just fine. However, this is not necessarily
a good idea. It is hard to be sure where they are going to land, and it
could be dangerous sitting under them as they fly overhead. -- RFC 1925