Example of Stack Unwinding in C++
Now let us discuss this concept with the help of a suitable example,
Implementation
C++
// C++ program to implement the concept of stack unwinding
#include <bits/stdc++.h>
using namespace std;
// cube root function
double cubeRoot(double x)
{
// An error situation occurs if the user enters a negative number
if (x < 0.0)
throw "Can not take cube root of a negative number"; // throw an exception of type const char*
return cbrt(x);
}
int main()
{
double x;
cout << "Enter a number: ";
cin >> x;
try // Look for exceptions within the try block and pass them to the linked catch block
{
double d = cubeRoot(x);
cout << "The curbe root of " << x << " is " << d << endl;
}
catch (const char *exception) // catch exceptions of type const char*
{
cerr << "Error: " << exception << endl;
}
return 0;
}
You can also try this code with Online C++ Compiler
Output:
Enter a number: -1
Error: Can not take cube root of a negative number
Try and compile with online c++ compiler.
First, the program determines if the exception can be handled quickly (which means it was thrown inside a try block). If not, the current function is ended, and the program checks to determine if the caller of the function will handle the exception. If not, the call is terminated and the caller's caller is checked. Each function is terminated in order until an exception handler is discovered or main() is stopped without the exception being handled. This is known as stack unwinding.
Now, consider how that relates to this program when an exception is triggered from within cubeRoot (). First, the program determines if the exception was thrown within a try block within the function. It was not the case in this instance. The stack then begins to unravel. First, cubeRoot() exits, and control is returned to main (). The program now determines whether we are inside a try block. We are, and there is a const char* handler, so the try block within the main handles the exception().
To conclude, cubeRoot() threw an exception, but it was caught and handled by the try/catch section in main(). Try blocks, in other words, capture exceptions not just from statements within the try block, but also from functions called within the try block.
Frequently Asked Questions
What does it mean to unwind the stack?
Stack unwinding is a mechanism used in C++ and other programming languages to recover or clean up records during runtime by deconstructing function entry.
What is stack winding and unwinding in C?
In C, stack winding defines the process of adding function calls to the call stack when a function is called. The process of removing these calls from the stack in order to restore control flow is known as stack unwinding. This usually happens during function returns or exception handling.
What is Rethrowing an exception in C++?
When an exception in C++ is thrown back, it means that it was originally caught in a `catch` block and sent up the call stack to handlers at a higher level by using the `throw;` statement.
Conclusion
In this article, we have discussed the concept of stack unwinding in C++. Stack unwinding in C++ is an essential process during exception handling. It ensures that all the local objects in the call stack are properly destroyed, resources are released, and destructors are invoked when an exception is thrown. This mechanism helps prevent memory leaks and other resource-related issues, making the program more robust and stable.
244+ registered 
