#define statements within a namespace

If I have a #define statement within a namespace as such:

namespace MyNamespace
{
  #define SOME_VALUE 0xDEADBABE
}

Am I correct in saying that the #define statement is not restricted to the namespace?

Is the following the "correct" thing to do?

namespace MyNamespace
{
  const unsigned int SOME_VALUE = 0xDEADBABE;
}

Correct,#define's aren't bound by namespaces. #define is a preprocessor directive - it results in manipulation of the source file prior to being compiled via the compiler. Namespaces are used during the compilation step and the compiler has no insight into the #define's.

You should try to avoid the preprocessor as much as possible. For constant values like this, prefer const over #define's.

I completely agree with the suggestions on the use of constants and the scope being unlimited for #defines.

However, if you do have to use preprocessor #define lines, please cover them up correctly for the expected scope,

namespace MyNamespace
{
  #define SOME_VALUE 0xDEADBABE
  // your code
  #undef SOME_VALUE
}

Why #defines?
I know one case where an embedded platform did not support constants in the code.
There was no way to initialize them...
It always helps to be more readable.

The preprocessor operates (conceptually at least, and often actually too) before namespaces and other language-level concepts "kick in" -- so yes, it's definitely much better to use language-level constructs such as const values wherever you can!

Yes. In general, using const values instead of #define'd values has many advantages. Restricting the scope of the variable is one of the advantages. The scope can be restricted to a namespace, or to any another valid scope this way (including at the class level, function level, etc).

If, for some reason, you couldn't change to the second case, I'm pretty sure you would have to take care to compile MyNamespace into its own object and link the objects separately (or possibly just run the preprocessor on that single namespace by itself). The C++ preprocessor should take that #define statement and essentially do a string replace anywhere that SOME_VALUE is seen in the source code. Hence if the preprocessor is not aware of the #define, SOME_VALUE cannot be replaced in another source file.