Question

I’ve grouped several message strings into a named (non anonymous) namespace in the .cpp file for a class handling output as seen in the code below:

namespace Messages
{
  static const std::string AppTitle = "The Widgetizer - Serving all your Widget needs";
  static const std::string SuccessMsg = "Great success! Widgets for all! ";
  static const std::string FailMsg = "No widgets for you!";
};

void Display::printTitle()
{
  out << Messages::AppTitle << std::endl;
}

void Display::printSuccessMsg()
{
  out << Messages::SuccessMsg << std::endl;
}

void Display::printFailMsg()
{
  out << Messages::FailMsg << std::endl;
}

My logic being that this way they’re all in one central location, under a namespace with a meaningful and self-documenting name, and they’re not exposed to the client code (as they would be if I had put the namespace in the .h file).

Is this a good practice generally or are there pitfalls to this that I’m not seeing?

Is the static keyword necessary if they’re in a file scope namespace like this?

In terms of best practices and accepted C++ idiom & style, would this be better off just as an anonymous namespace? Or simply as static const class members?

I admit it’s probably overkill for the small program I’m writing since they’ll probably only be used in these functions but generally speaking not hard coding message strings is a good habit no?

Answer 1

Is this a good practice generally or are there pitfalls to this that I’m not seeing?

Grouping related objects in a namespace is good practice if it makes the code clearer; there aren’t any particular pitfalls, but deeply nested namespaces can lead to excessively verbose code if you’re not careful.

Is the static keyword necessary if they’re in a file scope namespace like this?

You need either static or const to give them internal linkage, but it might be better to enclose your namespace in an unnamed namespace instead. Using static at namespace scope is deprecated, and just using const means you’ll get a surprise if someone declares extern objects with the same names.

In terms of best practices and accepted C++ idiom & style, would this be better off just as an anonymous namespace? Or simply as static const class members?

If grouping them in a named namespace makes the code more expressive, then do it; otherwise, don’t. I’d prefer not to make them class members unless necessary, to avoid adding unnecessary declarations to the header file.