Question

If I have a function like the following:

stack fillStack(){
  stack a;
  return a;
}

void main(){
  stack s=fillStack();
}

Consider we have a class called stack.
How many constructor and destructor will be called?

Answer 1

Here is what should be happening:

stack fillStack() {
  stack a;  // constructor
  return a; // copy constructor and destructor a
}

int main(){
  stack s=fillStack(); // copy constructor and destructor of the temporary
} // destructor s

In practice the standard explicitly allows the copy-constructors to be
optimized away (this is called copy elision) and the value to be
constructed in place. That could end up looking something like this:

void fillStack(stack&);

int main() {
  stack s;
  fillStack(s); // with reference
}

Although, copy-construction must still be well-formed even if the
compiler applies this transformation. If copy-construction can have
side-effects this optimization can lead to somewhat odd behavior (try
printing something from the copy-constructor and observe the behavior
on different optimization levels).

This optimization becomes largely unnecessary with C++11 due to
move-semantics.