43

My application uses another output than the standard output for logging information, which is why I wrote my own Log(), Error(), Panic() and Assert() functions. To organize things nicely, I enclose all the debugging stuff in a Debug namespace.

It would make more sense for the Assert() function to also provide a source file and line number, which is only possible using the __LINE__ and __FILE__ macros. However, it is pretty unpleasant, inefficient etc... to always have to specify these two parameters.

So this is how my code would look like:

namespace Debug { void Assert (int condition, std::string message, std::string file, int line); }

My question is, is it possible to place a macro which includes those two parameters inside the Debug namespace? Like this:

namespace Debug { void Assert_ (int condition, std::string message, std::string file, int line); #define Assert(a,b) Assert_(a, b, __FILE__, __LINE__) } // .... Somewhere where I call the function .... Debug::Assert (some_condition, "Some_condition should be true"); // Output: Assertion failed on line 10 in file test.cpp: // Some_condition should be true

Is this valid c++? If not, is there any way of making this work?

Improve this question
3
  • 3
    This will work, but the macro is not part of the namespace. Commented Aug 3, 2012 at 7:34
  • 1
    @PaulR So in other words, if I omit Debug::, the macro would still work? Commented Aug 3, 2012 at 7:39
  • 4
    No - you still need the namespace prefix (because all you're doing is translating Assert to Assert_ in the preprocessor) - the problem is that if you use Assert outside the namespace then it will still get translated, which is probably not be what you want to happen. Commented Aug 3, 2012 at 7:51

6 Answers 6

Reset to default
62

Is it possible to place a macro in a namespace in c++?

No.

#define is a preprocessor directive. The macros are being replaced before anything else apart from removing comments (which means, before compilation). So at the time macros are replaced, the compiler knows nothing about your namespaces.

As other people state, in your case it will be fine. However, This is how you can get problems:

namespace A { void Assert_ (int condition, std::string message, std::string file, int line) { std::cout << "A"; } #define Assert(a,b) Assert_(a, b, __FILE__, __LINE__) } namespace B { void Assert_ (int condition) { std::cout << "B"; } #define Assert(a,b) Assert_(a) } int main(int argc, char *argv[]) { A::Assert(0,"asdasd"); B::Assert(0,"asdasd"); }

So while it looks like the defines are "in the namespaces", they are not, and the last #define will be always be used, which in this case will lead to a compile-time error, because the code in main will be replaced by:

A::Assert(0); B::Assert(0);

instead of

A::Assert(0,"asdasd", _FILE_, _LINE_); B::Assert(0);
Improve this answer
Sign up to request clarification or add additional context in comments.

11 Comments

@Tibi - the way is not to use macros. Use constants or inline functions, defined in your namespace.
Why wouldn't it work. Assert would expand to Assert_ with the extra 2 parameters. What's the problem?
@LuchianGrigore - the "problem" is in the titme: "Is it possible to place a macro in a namespace in c++?"
@KirilKirov You lost me there a little bit. How can I use constants and inline functions to get the line and source file when the function is called?
@KirilKirov I don't see how that's a problem. You can put macros anywhere.
|
2

No, the preprocessor doesn't care about namespaces at all. In fact, the preprocessor runs, at least conceptually, before the compiler sees anything.

For myself, I just do a standard ASSERT macro, and expect that no "sane namespace" has something called ASSERT. Problem solved. Should I require a library that has an ASSERT of its own then I can still decide how to deal with this; however, the only library that I'm currently using with its own "assert" calls it BOOST_ASSERT or something like that...

Improve this answer

Comments

2 
namespace Debug { void Assert_(int condition, std::string message, std::string file, int line); #define Assert(a,b) Assert_(a, b, __FILE__, __LINE__) } // .... Somewhere where I call the function .... Debug::Assert (some_condition, "Some_condition should be true");

This specific usage would do exactly what you want, but the Assert macro is in no way part of the Debug namespace... it's exactly as if you'd done:

namespace Debug { void Assert_(int condition, std::string message, std::string file, int line); } #define Assert(a,b) Assert_(a, b, __FILE__, __LINE__) // .... Somewhere where I call the function .... Debug::Assert (some_condition, "Some_condition should be true");

Here, the substitution works not because Assert was in the Debug namespace (it's not in your code or this code, and the preprocessor has no clue what namespaces are about) - it works because Assert is recognised as an identifier for a macro, the substitution of Assert_ is made, then later the compiler proper happens to find there's a Debug::Assert_ So, say you have somewhere later in your translation unit you have some completely unrelated code:

my_object.Assert(my_functor);

The macro substituion will still kick in to produce a compile-time error saying you have the wrong number of arguments to a macro. Say the unrelated code was instead:

my_object.Assert(my_functor, "some text");

Then that would be replaced with:

my_object.Assert_(my_functor, "some text", __FILE__, __LINE__);

(Separately, it's standard practice not to use lower case letters in preprocessor macro names).

Improve this answer

1 Comment

Separately, it's standard practice not to use lower case letters in preprocessor macro names. I know, but take the windows api for example. There are many macros that don't respect this practice, so that they call the ascii/unicode version of another function.
0

put the namespace name before the macro name in both the definition and the use, and treat the definition as being outside of it.

namespace A { void Assert_ (int condition, std::string message, std::string file, int line) { std::cout << "A"; } #define A_Assert(a,b) A::Assert_(a, b, __FILE__, __LINE__) } namespace B { void Assert_ (int condition) { std::cout << "B"; } #define B_Assert(a,b) B::Assert_(a) } int main(int argc, char *argv[]) { A_Assert(0,"asdasd"); B_Assert(0,"asdasd"); }

the preprocessor will replace the macros with

A::Assert(0,"asdasd",__FILE__,22) B::Assert(0)
Improve this answer

3 Comments

Hi Ashton, it makes sense to add to your answer that you modified the accepted answer and write explicitly: that you changed Assert_ to A::Assert_ and also why you think that's a good idea.
the preprocessor does not know what namespaces are, this is an emulation. I would recommend using inline functions instead of macros wherever you can
OK, then I don't see a significant difference between yours and the accepted answer. If you think the accepted answer is the most sensible one, please upvote it instead, once you have the reputation
-1

You can try __PRETTY_FUNCTION __ macro to print all the namespaces including function arguments.

Improve this answer

1 Comment

While this might be a valuable hint to solve the problem, an answer really needs to demonstrate the solution. Please edit to provide example code to show what you mean. Alternatively, consider writing this as a comment instead.
-4

Yes, and your macro would expand to exactly what you expect.

Debug::Assert (some_condition, "Some_condition should be true");

would be replaced by

Debug::Assert_(some_condition, "Some_condition should be true", __FILE__, __LINE__)
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.