How to make C++ give detailed exception information just like python does?

Question

With python, when an exception occurs, I get detailed information about what file raised an error, even without a catch:

def hello():
    raise Exception;

hello() 

Execution result >>

Traceback (most recent call last):
  File "exceptionExample.py", line 4, in <module>
    hello()
  File "exceptionExample.py", line 2, in hello
    raise Exception;
Exception

With C++, the information is not that useful:

#include <iostream>

using namespace std;

class Error
{
};

int value()
{
    throw Error();
}

int main(int argc, char *argv[]) {
    value();
}

>>

terminate called after throwing an instance of 'Error'
Run Command: line 1: 52772 Abort trap: 6           ./"$2" "${@:3}"

How can I make C++ give more detailed information about what module raised an error and from which line?

I'd like to use it without a catch clause.

http://stackoverflow.com/a/4611112/1903116 This should help you — thefourtheye, Jun 14 '13 at 15:25
Also possibly useful: http://stackoverflow.com/q/77005/646543. btw, the term you're looking for is "stacktrace" :). — Michael0x2a, Jun 14 '13 at 15:35

score 3 · Accepted Answer · edited May 23 '17 at 10:25

You could use the __FILE__ and __LINE__ definitions in your exception message.

For example:

#include <stdexcept>

class Error : public std::runtime_error
{
  public:
    Error (const std::string &message)
      : std::runtime_error(message)
    {}

};

int value()
{
    std::stringstream ss;
    ss << "Issues at " << __FILE__ << " on line " << __LINE__;
    throw Error(ss.str());
}

In this example, I made Error inherit from std::runtime_error (which has a constructor to allow you to pass a message as a string)...

Additionally, take a look at this SO question: Global Exception Handling - note the answer about using the set_terminate function. This will allow you to install a global handler that ensures the message is printed as you want. Here's some info on set_terminate().

Python gives a stack trace for an uncaught exception. The answer I've provided only tells you the file and line number. If you need a stack trace, several commenters have referenced some other SO questions that give advice on how to do this in C++. Beware of non-standard solutions to this issue, however.

3

Still missing a stack trace though. – Jun 14 '13 at 15:29

Ivaylo Strandjev · Answer 2 · 2013-06-14T15:29:59.237

0

You can create your exceptions so that they wrap the stack trace when they are created. Still please take care only to log this in debug mode as logging stack trace may be a security concern.

Also using a debugger may help you.

edited Jun 14 '13 at 15:29

answered Jun 14 '13 at 15:21

Ivaylo Strandjev

69,226
18
123
176

A security concern? How does that show any information an adversary couldn't easily get via a debugger (which they'll be using anyway if they attack at this level)? – Jun 14 '13 at 15:31
I said that this information should not be logged. Logs may be copied or moved to another machine that may later be compromised. Usually security of logs is less than the security of the product itself. Still knowing the stack trace may help a potential atacker – Ivaylo Strandjev Jun 14 '13 at 15:41

score 0 · Answer 3 · answered Jun 14 '13 at 15:41

There is no portable way to get the stack trace, a trick is to use an object in function context to save the information

struct StackTraceInfo {
    const char *filename;
    int line;
    static std::vector<StackTraceInfo *> stack;
    StackTraceInfo(const char *filename, int line) :
      filename(filename), line(line)
    {
        stack.push_back(this);
    }

    ~StackTraceInfo()
    {
        stack.pop_back();
    } 
};

#define ENTER StackTraceInfo(__FILE__, __LINE__) sinfo_;

The in every function just add a line with ENTER at the very start of the body

int foo() {
    ENTER
    ....
    return 42;
}

in case of an exception before throwing you need to save the current stack trace using the content of global StackTraceInfo::stack vector so who displays the message can access this information. Note that you cannot access the stack information in the exception handler because the stack has been already unwound at that point.

Note also that if your application is multithreaded you need using a separate stack for each thread using tread local storage instead of a global.

score 0 · Answer 4 · answered Dec 24 '19 at 16:32

Using standard C++11 one can thankfully obtain something quite similar to the Python backtrace, using:

`std::nested_exception` and `std::throw_with_nested`

It is described on StackOverflow here and here, how you can get a backtrace on your exceptions inside your code without need for a debugger or cumbersome logging, by simply writing a proper exception handler which will rethrow nested exceptions.

Note that you have to wrap all functions which you want to appear in your backtrace in try/catch and you need nonstandard macros (__FILE__, __func__, __LINE__) to automatically add source location information.

Since you can do this with any derived exception class, you can add a lot of information to such a backtrace! You may also take a look at my MWE on GitHub or my "trace" library, where a backtrace would look something like this:

Library API: Exception caught in function 'api_function'
Backtrace:
~/Git/mwe-cpp-exception/src/detail/Library.cpp:17 : library_function failed
~/Git/mwe-cpp-exception/src/detail/Library.cpp:13 : could not open file "nonexistent.txt"

How to make C++ give detailed exception information just like python does?

4 Answers4

std::nested_exception and std::throw_with_nested

`std::nested_exception` and `std::throw_with_nested`