Re: vector push_back deletes objects
On Dec 15, 6:26 am, Rolf Magnus <ramag...@t-online.de> wrote:
criman...@googlemail.com wrote:
On 15 =D0=B4=D0=B5=D0=BA, 04:54, cronusf <cron...@gmail.com> wrote:
Whenever I add an object to a vector, the destructors of
all the previous objects in the vector get called. Why?
It seems a push_back would just copy the object to add to
the next free slot in the vector, and leave all the other
objects alone. The only time I could see this is if the
vector needs to add more memory, but this shouldn't happen
with every push_back call.
It _happens_ with every push_back.
It _can_ happen with every push_back, but doesn't have to.
It can't happen with every push_back. As Alf said, std::vector
requires push_back to have amortized constant complexity, which
effectively means exponential growth (in practice, multiplying
by 1.5 or 2).
If you don't want vector reallocation at every push_back, call
Vec.reserve().
Calculate before pushing if you can how much elements you need or
just reserve 2*current_size elements every time you reach limit.
Most implementations of push_back already do something like
that, but that's not required by the C++ standard.
It is.
I fully instrumented his code:
#define TRACE(f) std::cout << "Location:" #f << " (" << this << ")
\n"
then TRACE(ctor), TRACE(copy), TRACE(dtor) and TRACE(asgn) in
the normal constructor, the copy constructor, the destructor and
the assignment operator, to see what was going on. The number
of copies very definitely depends on the compiler (or the
library implementation---I'm not sure which), but with the
Microsoft compiler, you get an extra copy in the push_back, I
don't know why. The destructor he's seeing is of this copy.
FWIW: when trying to analyse this sort of thing, do instrument
all "special" functions, and output the address when you do so
(to distinguish instances, even copies). I've even considered
creating a base class which does this, e.g.:
struct Traced
{
Traced() { TRACE(ctor); }
Traced(Traced const& ) { TRACE(copy); }
~Traced() { TRACE(dtor); }
Traced& operator=(Traced const& ) { TRACE(asgn); return
*this; }
};
It will help a lot in understanding. The standard allows extra
copies in a lot of places, and different compilers do different
things; unless you've instrumented all of the big four, with
output of the address, it's pretty much impossible to follow
what's happening.
--