static string constants in class vs namespace for constants [c++]

Question

I want to declare string constants that will be used across various classes in the project. I am considering two alternatives

Option 1:

#header file 
class constants{
    static const string const1;
};

#cpp file

const string constants::const1="blah";

Option 2:

#header file 
namespace constants{
    static const string const1="blah";
};

Just wondering what would be a better implementation.

Already looked at

http://stackoverflow.com/questions/3299765/where-to-store-class-specific-named-constants-in-c

http://stackoverflow.com/questions/2465546/where-to-put-constant-strings-in-c-static-class-members-or-anonymous-namespace

---

UPDATE:

Option 3:

Based on the suggestions from "potatoswatter" and "sellibitze" i currently have the following implementation?

#header file
namespace constants{
    extern const string& const1(); //WORKS WITHOUT THE EXTERN  ***WHY***
};

#cpp file
namespace constants{
   const string& const1(){static string* str = new string ("blah"); return *str;}
}

I'm including the header file where i need to use the constants. Are there any major cons of this implementation?

Answer 1

Option 1 achieves the same as Option 2, but in a messier way.

If you're going to use a class that just has static members, especially for global access/constants, use a namespace.

Answer 2

Option 2 doesn't appear to be a solution. The strings will still be defined separately for each source file, despite appearing in the same namespace.

So then Option 1 is better, but I don't like using a class as a namespace.

Try using extern:

#header file 
namespace constants{
    extern const string const1;
}

#cpp file

const string constants::const1="blah";

Note that this may run afoul of the Static Initialization Order Fiasco unless you ensure that the string literal source is compiled/linked/initialized first, which is implementation-dependent.

The easier way is just to use C string literals. If you want blah, write "blah". Is this part of a localization system or something?

Answer 3

Neither. I'd go with this:

// header file
namespace constants {
extern const char const1[];
}

// cpp file
namespace constants {
extern const char const1[] = "blah";
}

The header file contains a declaration of const1 with incomplete type but convertible to char const* and the cpp-file contains a definition of the character array with external linkage. There is no dynamic initialization like you have with std::string. So, that's a plus, IMHO.