Easy way of constructing information message for throwing std::exception using preprocessor macros

Question

At certain points of my code I want to throw an exception and give it some information about the code where I've thrown it. Something like

void Foo() {
    if(condition)
        throw std::logic_error(ERROR_MSG);
}

// somewhere later in code
try {
    Foo()
} catch (std::exception & e) {
    e.what();
}

Now the question is – how do i construct this error message? I would like to give information about the file, the line of code, the function name and a bit of an own information. Something (I suspect) should be pretty standard usage – but after an extensive search I still didn't find something useful about this (as I thought) easy subject.

I just would like to write something like this

throw std::logic_arrow("Whoops! Error in (" +
                        __func__ + ") " + __FILE__ + ":" + __LINE__);

But this doesn't seem to work for various reasons. Here is what I achieved so far with my search:

• There is already a similar question here, but this is about if one should use these macros, not how
• This question deals with concatenating __FILE__ and __LINE__ in a macro, so I was a bit further to my answer
• The __func__ macro seems to make difficulties, since "These identifiers are variables, not preprocessor macros, and may not be used to initialize char arrays or be concatenated with string literals" following to the gcc homepage. Well, it is now a variable I can use for instance in the printf function like here – but I didn't manage to master the transfer to my own problem
• One guy was worried about a cleaner solution than Macros, using inline functions, so I could even improve a solution
• C++14 techniques where suggested in another thread, using operator ""s

Answer 1

Just do this:

throw std::logic_error(std::string{} + "Whoops! Error in (" +
                    __func__ + ") " + __FILE__ + ":" + std::to_string(__LINE__));

live example

Sometimes you can format it like the IDE does its own error messages, then get double-click support.

throw std::logic_error(std::string{} + __FILE__ + "(" + std::to_string(__LINE__) + "): [" + __func__ +"] " + "Whoops! Error!  Whodathunk.");

or somesuch.

template<class E>
[[noreturn]] void fancy_throw( std::string msg,
  char const* file, char const* function,
  std::size_t line
) {
  throw E( std::string{} + file + "(" + std::to_string(line) + "): [" +
    function + "] " + msg );
}
#define EXCEPTION( TYPE, MESSAGE ) \
  fancy_throw<TYPE>( MESSAGE, __FILE__, __func__, __LINE__ )

and we get:

EXCEPTION( std::logic_error, "Whoops! Error!  Whodathunk." );

live example

I think this is poor. Instead, we can have a SOURCE_ERROR macro:

inline std::string make_source_error( std::string msg,
  char const* file, char const* function,
  std::size_t line
) {
  return std::string{} + file + "(" + std::to_string(line) + "): [" +
    function + "] " + msg;
}
#define SOURCE_ERROR(...) make_source_error(__VA_ARGS__, __FILE__, __func__, __LINE__ )

which places flow control outside of macros, but does the string building with the tokens inside the macro, and builds the string inside a normal function.

Only the things that must be done in a macro (or copy/pasted everywhere we use it) are done in a macro here. Which is how it should be.

live example

... and __VA_ARGS__ are there because the macro language doesn't understand some uses of , in C++.

Answer 2

I would suggest looking into Boost.Exception which does this and more (it's one of the most lightweight Boost libraries consisting only of a few headers).

Answer 3

I've been doing that by using a couple of macros (so that it would reduce the hassle of typing the whole thing each time, plus it adds consistency), and then creating temporary std::strings to concatenate them easily. There might be a simpler way, but it works well and you only type it once.

// Helper macros to convert a macro string constant to an actual string in another macro.
#define STRINGIFY2(x) #x
#define STRINGIFY(x) STRINGIFY2(x)

#define CURRENT_LOCATION std::string("At "STRINGIFY(__FILE__)":") + __func__ + std::string("(" STRINGIFY(__LINE__) "): ")

You can then use it and add some info afterwards that way:

throw std::logic_error(CURRENT_LOCATION + "Description here");

Watch it live here

Answer 4

Okay, after some trying I got an "easy" solution which doesn't even need the use of macros, only an inline function. It does compile with g++ 6.1.1 and also "work" es expected (throwing the exception).

#include <iostream>
#include <stdexcept>
inline const std::string
Exception_helper(   const std::string msg,
                    const char * const func_name,
                    const char * const file_name,
                    const std::size_t line_number) {
    return msg + " " + func_name + "() in " + file_name + ":" +
        std::to_string(line_number);
}

void Foo() {
    throw std::logic_error(Exception_helper("Whoops! Error in",
                                            __func__,
                                            __FILE__,
                                            __LINE__));
}

int main() {
    try { Foo(); }
    catch (std::exception & e) {
        std::cerr << e.what() << std::endl;
        exit(1); }
    return 0;
}

I could try to even implement Exception_helper as constexpr function, but no time for that at the moment.

Again, thanks to all who helped me find an answer. Stackoverflow is the best.