std vector T = int, second resize causes crash. when i resize and try to write on the new space it fails after the second resize. why? - crash

Question

I detect if the index i want to write is outside of capacity, if so i resize it
large enough to accommodate the new index. i immediately call myVector.at( iIx ) = newValue
do I have to do something to reset the vector? it works after the first resize,
but not after the second. I expect a venerable standard to work off the shelf, instead of requiring days of research. Years ago i wrote my own resizable array, I guess I will go back to that code soon.
here is the code, which works correctly for the first resize.
if ( iIx >= iCapacity ) { // need to resize
iAddNeeded = miMallocSize;
while ( iIx >= iCapacity + iAddNeeded ) // increases the add by miMallocSize until its enough
iAddNeeded += miMallocSize;
if ( iCapacity + iAddNeeded + miMallocSize >= iSysMax )
iNewSize = iSysMax;
else
iNewSize = iCapacity + iAddNeeded + miMallocSize; // at least miMallocSize extra, no more than 2 miMallocSize extra
resize( iNewSize, 0 ); // this reallocs, AND marks the space with zeros
iCapacity = capacity(); // better be large enough now 221107
} // else { // if ( iIx < iCapacity ) {
if ( iIx >= iCapacity )
Hcx( this, DL5, "T ERROR resize FAIL iCapacity %d index %d", iCapacity, iIx );
else {
at( iIx ) = newElement;
iTest = at( iIx );
} // else {
I expect the vector object to function properly after it is resized. it returns the expected capacity, but then when i write to the new space it crashes.

Answer 1

I found out the behavior of std::vector is unexpected. when you size the vector for unknown reasons the space is not necessarily writable. what this means is capacity is not what you think. capacity is supposed to
mean what has been allocated. but that is not enough to make the space writable. If you are manually coding a dynamic array of ints plain old allocation IS enough to make space writable. You malloc some space and write on it. With std vector you have to also do something to make the new space writable. It is analogous to construction. But ints do NOT need construction. I think the design is weak, at least for atomic types like int. Assuming you are growing, when you use std::vector resize it will realloc the data and initialize SOME of it. The capacity however may exceed what you asked for. The designers do not permit the caller to specify the resulting size. The vector decides how much to allocate. capacity tells you how much is allocated, BUT YOU CANT NECESSARILY WRITE ON IT.