C++ – Class Containing Constants of std::string

c++constantsstaticstring

So I'm currently working on a school-project with C++, which I'm not really familiar with.
I would like to create a class, containing all my constants (string,int,double,own classes)
I was trying this, which has always worked for me in Java:

class Reference {


    //Picture-Paths
    public:
    static const std::string deepSeaPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
    static const std::string shallowWaterPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
    static const std::string sandPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
    static const std::string earthPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
    static const std::string rocksPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
    static const std::string snowPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";

};

In C++, however, I get the following error:

Error   C2864   'Reference::Reference::earthPath': a static data member with an in-class initializer must have non-volatile const integral type bio-sim-qt  e:\development\c++\bio-sim-qt\bio-sim-qt\Reference.hpp  16  1

So is there any way for me to store for example String-Constants like this?
If yes, is there even a better way to do it? If no, is there another way (#define?) ?

Best Answer

In C++17, the recommended way of defining string constants if by using an inline constexpr std::string_view. Example:

namespace reference
{
    inline constexpr std::string_view deepSeaPath{R"(something)"};
    // ...
}

This is great because:

std::string_view is a lightweight non-owning wrapper that can efficiently refer to string literals without any additional costs.
std::string_view seamlessly interoperates with std::string.
Defining the variables as inline prevents ODR issues.
Defining the variables as constexpr makes it clear to both the compiler and other developers that these are constants known at compile-time.

If you do not have the luxury of using C++17, here's a C++11 solution: define your constants as constexpr const char* in a namespace:

namespace reference
{
    constexpr const char* deepSeaPath{R"(something)"};
    // ...
}

Related Solutions

C++ Constants – Should You Use std::string or const char*?

Usually you should prefer std::string over plain char pointers. Here, however, the char pointer initialized with the string literal has a significant benefit.

There are two initializations for static data. The one is called static initialization, and the other is called dynamic initialization. For those objects that are initialized with constant expressions and that are PODs (like pointers), C++ requires that their initialization happens at the very start, before dynamic initialization happens. Initializing such an std::string will be done dynamically.

If you have an object of a class being a static object in some file, and that one needs to access the string during its initialization, you can rely on it being set-up already when you use the const char* const version, while using the std::string version, which isn't initialized statically, you don't know whether the string is already initialized - because the order of initialization of objects across translation unit boundaries is not defined.

C++ – Define a Static Data Member of Type const std::string

Since C++17, you can use an inline variable:

// In a header file (if it is in a header file in your case)
class A {   
private:      
  inline static const string RECTANGLE = "rectangle";
};

Prior to C++17, you have to define your static member outside the class definition and provide the initializer there.

// In a header file (if it is in a header file in your case)
class A {   
private:      
  static const string RECTANGLE;
};

// In one of the implementation files
const string A::RECTANGLE = "rectangle";

The syntax you were originally trying to use (initializer inside class definition) is only allowed with integral and enum types.

Best Answer

Related Solutions

C++ Constants – Should You Use std::string or const char*?

C++ – Define a Static Data Member of Type const std::string

Related Question