C++ vector of objects and excessive calls to destructor? - c++

Question

What I'm wondering about is whether the code calls the destructor one too many times and if its correct to code in this manner. It seems like the object created goes out of scope before getting loaded into the vector but the object doesn't die, instead it stays in the vector and ends up destructing again when the program is done. Heres the output:
object::constructor:
before push_back
object::destructor:
object::constructor:
before push_back
object::destructor:
object::destructor:
object::call(): begin
0
object::call(): end
object::call(): begin
1
object::call(): end
object::destructor:
object::destructor:
Process returned 0 (0x0) execution time : 0.313 s
Press any key to continue.
This is the main.cpp
#include <vector>
#include <iostream>
#include "object.h"
int main()
{
int max = 2;
std::vector <object> OBJECTS;
for(int index = 0; index < max; index++)
{
object OBJECT(index);
std::cout<<"before push_back"<<std::endl;
OBJECTS.push_back(OBJECT);
}
for(int index = 0; index < max; index++)
OBJECTS[index].call();
return 0;
}
and this is the object.h
#ifndef OBJECT_H
#define OBJECT_H
#include <iostream>
class object
{
private:
int value;
public:
object(){}
object(int value)
{
std::cout<<"object::constructor: "<<std::endl;
this->value = value;
}
~object()
{
std::cout<<"object::destructor: "<<std::endl;
}
void call()
{
std::cout<<"object::call(): begin"<<std::endl;
std::cout<<value<<std::endl;
std::cout<<"object::call(): end"<<std::endl;
}
};
#endif
This is the code from the answer Chowlett below, just in case the site goes under.
#include <iostream>
#include <vector>
class object
{
private:
int value;
public:
object(){}
object(int value)
{
std::cout<<"object::constructor: "<< value << std::endl;
this->value = value;
}
object( const object& o )
{
std::cout<<"object::copy-constructor: " << o.value << std::endl;
this->value = o.value + 10;
}
~object()
{
std::cout<<"object::destructor: "<< value << std::endl;
}
void call()
{
std::cout<<"object::call(): begin"<<std::endl;
std::cout<<value<<std::endl;
std::cout<<"object::call(): end"<<std::endl;
}
};
int main()
{
int max = 3;
std::vector <object> OBJECTS;
for(int index = 0; index < max; index++)
{
object OBJECT(index);
std::cout<<"before push_back: capacity="<< OBJECTS.capacity() << std::endl;
OBJECTS.push_back(OBJECT);
std::cout<<"after push_back: capacity="<< OBJECTS.capacity() << std::endl;
}
for(int index = 0; index < max; index++)
OBJECTS[index].call();
return 0;
}

Answer 1

The compiler generated a copy-ctor for you. Add one with some debug output and you can understand what your code is doing:
object( const object& o )
{
std::cout<<"object::copy-constructor: "<<std::endl;
this->value = o.value;
}

Answer 2

What's happening is that the vector is reallocating to make space.
OBJECTS starts off with capacity equal to zero. The loop constructs OBJECT = object(0), then copy-constructs a copy of that object to pass to push_back. push _back notes there's not enough room (1 > 0!), so it reallocates vector to have a capacity of 1 and puts the copy in. Then it destructs OBJECT.
Next time through the loop, OBJECT = object(1) is constructed, then copy-constructed for push_back. There's not enough room again, so OBJECTS is reallocated to have greater capacity - and the object(0) already in it is copy-constructed into the reallocated space, and the original destructed. Then the copied object is put in, and the OBJECT is destructed again.
This variation on your code should make it clear what's going on. I've made the code write the vector capacity before and after each push_back; and I've added a logging copy-constructer. I've also made the copy-constructer add 10 to value each time it's called, so you can see how each individual object is copied around.