C++ equivalent of Java static final String

Question

I often need to define string constants associated with a class. Examples would be XML attributes, default filenames and many more.

In Java I would simply define something like

public static final String KEY = "attribute";

inside the class or interface.

In C++ the following would not compile:

class Example {
public:
    static const std::string KEY = "attribute";
}

Instead, I would have to write:

class Example {
public:
    static const std::string KEY;
}

const std::string Example::KEY = "attribute";

This is something I absolutely want to avoid because of its redundancy and verbosity.

The best solution I found so far is to use functions:

class Example {
public:
    static std::string KEY() const { return "attribute"; }
}

This also provides some encapsulation and flexibility. However it might seem a bit weird to use a function just to define a constant.

So my question is, does this solution have major drawbacks and if yes, what are better alternatives?

Answer 1

In c++03, your best option is to use a function the way you are using, and this is awkward. The only thing is, why are you returning std::string and paying it's construction price, when you can return const char* const free of charge.

If, for some reason, you really have to have const std::string (again, it runs against my whole experience, so you might want to reconsider) following code works best in terms of efficiency (your current version calls std::string constructor on every call!):

class Example {
public:
    static const std::string& key() {
       static const std::string the_key = "That's my key!";
       return the_key;
    }
}

In c++11, you have several options, of which I find the best a constexpr:

class Example {
public:
    static constexpr const char* const KEY = "TheKey";
}

The other option is in-place initialization of your const string, but why pay the price of it?

class Example {
public:
    static const std::string KEY = "TheKey";
};

Answer 2

Whereas with Java, classes and their static members are loaded along with the class—which means that the class as a unit, or as part of a JAR, is replaceable—in C++ it doesn't go that way. If you stick things in headers, you pay the price of not being able to replace them until you re-compile everything that included them.

That's why the idiomatic—and most beneficial—way would be to indeed declare them in the header and provide the implementation where it belongs, in the translation units, which can be linked in to whatever other binaries. So consider readjusting your outlook (I moved from C# to C++ so I had this happen to me more than once).

But you don't have to go the way of strings at all. You can create enums, which is a much more elegant and type safe way to achieve this sometimes. With enums (and specifically enum classes), you can't just pass in the wrong string. You have to pass in one of a set of valid values.

As an example you could do:

class Example {
public:
    enum class Attributes {
        One,
        Two,
        // ...
    };
}

And then, when it matters, and when you have local knowledge of what's what, you can map the enum values to actual strings or whatnot that the actual implementation requires.

Answer 3

You can define constructor of the class so that each time the class is used the constructor will automatically assign the value "attribute to the string"

class Example {
   public:
      static const std::string KEY;
      Example()
      {
          KEY="Attribute";
      }
};