Where does exception object have its space, heap or stack, and how to access it in different class?

Question

Recently an interviewer asked me where the exception object in C++ is allocated, heap or stack? I'm not sure but I answered stack since I thought there is no "new" or "malloc". Is it correct?

Then he kept asking me that if it's on stack, assuming class A throw a exception object, let's say "e", and class B catch "e". Since "e" is on the stack of A, then how does B can have the access to this "e"?

I'm not very clear about the second question. Could anyone can give me some example code showing that "class A throw e and class B catch it"? Also, I guessed B can catch e by copying the value or address but the interviewer only denied my answer without giving me right one, so what is the right answer, is there any mechanism can ensure class object can catch exceptions from other class objects? Thanks~

Answer 1

From [except.throw]/15.1/4:

The memory for the exception object is allocated in an unspecified way, except as noted in 3.7.4.1.

The final reference, [basic.stc.dynamic.allocation]/4, says:

[Note: In particular, a global allocation function is not called to allocate storage for [...] an exception object (15.1). — end note]

Answer 2

It can't be stack as the when exception is thrown stack unwinds and you'd lose the exception object if allocated in the frame that caused the exception.

I remember reading something about it in C++ Primer, 5Ed. It said

The exception object resides in space, managed by the compiler, that is guaranteed to be accessible to whatever catch is invoked. The exception object is destroyed after the exception is completely handle.

And looking at @Kerrek's asnwer above along with it, I believe it's a separate space allocated and is specific to compilers.

Answer 3

"but I answered stack since I thought there is no "new" or "malloc". Is it correct?"

Basically yes, though exception handling is a bit special because it unwinds the stack for throw operations.

 struct SomeException {
 };

 void throwing_func() {
      throw SomeException();
 }

 int main() {
     try {
         throwing_func();
     }
     catch(const SomeException& ex) {
         std::cout << "Caught 'SomeException' exception" << std::endl;
     }
 }

The local scope of

void throwing_func() {
      throw SomeException();
}

is somehow equivalent as looking to a local scope and matching that kind of local scope with the best matching catch(...) statement.

Answer 4

throw new std::exception vs throw std::exception

The above link has a pretty good answer.

I think the answer would be "usually" heap since you are throwing an object which would be located on the heap but if it is a static object (not sure if such a thing exists) then it would be on the stack.