how to hold user defined type in STL stack?

Question

My question is: is the following code about STL stack correct?

in the code, complex is a user defined class with constructor and destructor defined. after place 1, complex constructor and destructor are called 5 times respectively, and after place 2, complex destructor are called 5 times again due to pop(). so in total destructor are called more than constructor. IMO it should not happen. Is my code correct? if not correct how to correct it? suppose I still use stack rather than stack

#include <stack>  
#include "complex.h"  
using namespace std;   
void test_stack(){   
stack<complex> mystack2;      
cout << "Pushing complex..." << endl;  
 for (int i=0; i<5; ++i) {   
  complex c(i,i);     
  mystack2.push(c);   
 }  
 //place 1  
 cout << "Popping out complex..." << endl;   
 while (!mystack2.empty()) 
 {  
    cout << " " << mystack2.top();  
    mystack2.pop(); //void pop();  
 }  
 //place 2  
 cout << endl;  
}

Karoly Horvath · Answer 1 · 2013-05-08T00:34:27.520

1

To simplify it, I won't mention that each of these happens 5 times:

complex c(i,i); - constructor called
mystack2.push(c); - constructor called
c falls out of scope - destructor called
mystack2.pop(); - destructor called

Note: To see what's going on add trace messages in the constructor and destructor. Don't forget the rule of three.

edited May 08 '13 at 00:34

answered May 08 '13 at 00:04

Karoly Horvath

94,607
11
117
176

score 1 · Answer 2 · answered May 08 '13 at 00:31

You are probably not taking into account the copy constructor which would be called at

mystack2.push(c);

For value-type classes like complex, a copy constructor will be created for you automatically if you don't define your own.

You can create a copy constructor with something like this:

complex( complex const & other )
 : real(other.real)
 , imag(other.imag)
{
   cout<<"complex::copy_constructor called"<<endl;
}

score 1 · Accepted Answer · edited May 23 '17 at 12:21

To answer your original question, there is nothing wrong with your code. However, your understanding is a little off.

As others have noted, mystack2.push(c) will call the complex's copy constructor. So in total you have 5 calls to the constructor, 5 to the copy constructor, and 10 to the destructor.

This brings up a few important points. As you've noticed, the following code:

for (int i=0; i<5; ++i) {   
    complex c(i,i);     
    mystack2.push(c);   
}

First creates a complex (c), then a copy is added to the stack, and the original complex is destroyed when c goes out of scope. In C++11, the extra copy is unnecessary, and you can do the following:

for (int i=0; i<5; ++i) {   
    mystack2.emplace(i, i); 
}

Which will let the stack do the construction of the object, eliminating the need for a copy.

Another point which I think led to your confusion that the constructor was called 10 times, is that you said complex only defines a constructor and a destructor. If you don't define a copy constructor (and don't mark it private or deleted), one will be created automatically by the compiler. There's actually a little more to it than it with C++11, and I direct you to this question for details - Conditions for automatic generation of default/copy/move ctor and copy/move assignment operator?. The important thing to note, though, is that in this case your call to push was definitely calling a compiler-generated copy constructor.

Correct. I did not realize copy constructor is called in push(c). Note the definition of push: void push ( const T& x ). I thought it is like foo(const T& x) where x is pass by reference so no new complex is constructed. but it seems push ( const T& x ) works like copy construct: complex (const T& x). — user389955, May 08 '13 at 03:13
@user389955: The new `complex` is not constructed while making the call to `push()`. It is constructed *inside* of push because the stack saves a *copy* of the value that you pass in. — Brent Bradburn, May 08 '13 at 13:05

how to hold user defined type in STL stack?

3 Answers3