why when I create an object of a class on the stack, why it didn't delete after leaving the scoop.?

Question

this is my class

class game
{
private:
    vector<stack> stacks_;
public:
    game();
    void solve();

   friend ostream& operator<<(ostream& os,const game& game);
};

this is the constructor.

game::game()
{
    for (int i = 0; i < 3; i++)
    {
        stack s;
        stacks_.push_back(s);
    }
    cube blueCube(4,0);
    stacks_[0].push(blueCube);

    cube yellowCube(3,1);
    stacks_[0].push(yellowCube);

    cube redCube(2,2);
    stacks_[0].push(redCube);

    cube blackCube(1,2);
    stacks_[0].push(blackCube);
}

in the main function

int main()
{
  game g;

  cout<<g<<endl;

}

after creating the game class why the vector in the game class still have the object. I thought all objects that are declared like that cube blueCube(4,0); without new are on the stack and when I leave the constructor all of them will be deleted. Can anyone explain please ?

You're pushing a copy of those object which are then owned by the `vector`. Also provide a [minimal reproducible example](https://stackoverflow.com/help/minimal-reproducible-example). — Jason, Oct 20 '22 at 10:32
How did you come to the conclusion that the objects weren't destructed? — thedemons, Oct 20 '22 at 10:32
Note that `delete` and `destruct` are two different (though linked) concepts. You are asking about `destruction` and _not_ `delete`. — Mike Vine, Oct 20 '22 at 10:33

463035818_is_not_an_ai · Accepted Answer · 2022-10-20T10:50:48.527

I suppose you have a using namespace std; in your code. Don't do that. In the code you posted vector can be std::vector but it could be also something else. I'll asssume it is std::vector. In your code stack cannot be std::stack (it missing a template argument) so it must be something else.

So lets consider this:

{
    stack s;
    stacks_.push_back(s);
}

s will be destroyed when it leaves the scope. push_back stores a copy of s in the vector. All fine. The copy is not affected by deleting the original (unless stack is broken in a weird way. Not respecting the rule of 3/5/0 would cause issues here).

Assuming stack also stores copies of the arguments passed to push_back, the same happens as above. There is no problem with the original cubes getting destroyed.

To avoid the temporaries and the copying you can use emplace_back which, given arguments for the elements constructor, constructs the elements in place.

why when I create an object of a class on the stack, why it didn't delete after leaving the scoop.?

1 Answers1